← Back to history

Pipeline run

2f41f803-2392-4fba-bac3-8ea9ed2a2eb1

Pipeline LLM cost (USD)
API 1: $0.0054 API 2: $0.0005 API 3: $0.0000 Total: $0.0058

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 · Web app business logic
Build and tune scalable Java Spring Boot enterprise apps, making design decisions with architects, defining standards, and improving delivery processes. You’ll work across microservices, APIs, SQL/JPA, messaging, and some front-end integration.
"Development of end user application with high scalability and high throughput."
Tech stack maturity
Mainstream Modern
The stack centers on widely used enterprise Java and frontend technologies like Spring Boot, React/Angular/Vue, REST, JPA, and Kafka, which are current and common but not bleeding-edge or cloud-native specific.
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 (47)
Java Spring Boot Spring Security Spring Integration Spring Batch Spring Data Spring Cloud JPA Hibernate MyBatis Linux Unix SQL JMS Kafka HTML5 CSS JavaScript ES6 jQuery Bootstrap React AngularJS Vue.js REST +22
Skill cluster (18 dimension groups, role-scoped)
ORMs and Data Access Layers
Spring Data JPA Hibernate
Programming Languages
Java JavaScript
Web Application Frameworks
Spring Boot Node.js
API Design and Contracts
REST
Asynchronous Messaging and Event Streaming
Kafka
Backend Authentication and Authorization
Spring Security
CSS Architecture and Styling
CSS
Cloud Platforms
AWS
Component Libraries and Design Systems
Bootstrap
Container Orchestration Platforms
Kubernetes
Containerization and Image Builds
Docker
Integration Protocols & Standards
SOAP
Relational Data Modeling
MySQL
Relational Database Design
Oracle Database
Screen Navigation and State
AngularJS
UI Frameworks and Rendering
React
Web UI & Integration Frameworks
jQuery
Cross-cutting / unaligned
Spring Integration Spring Batch Spring Cloud MyBatis Linux Unix SQL JMS HTML5 ES6 Vue.js Git Bitbucket MariaDB Agile Continuous Integration Release Automation Unit Testing OpenShift Hive Impala Spark DynamoDB MongoDB Cassandra HBase
Show KRA description ↓
Collaborate with product owners and architects on making design decisions.Development of end user application with high scalability and high throughput.Provide technical and design guidance and create standards.Improve, optimize and identify opportunities for improved software development processes.Expertise in designing enterprise applications Working experience on Java 8 (Good to have 9/10/11)Springboot microservices, Spring (spring security, spring integration, spring batch, spring data, spring cloud, spring boot)JPA (Java Persistent API), Hibernate, MyBatisUnix/Linux-Any Unix flavorSQL/Database knowledge/Performance-TuningAny messaging knowledge [JMS, KAFKA]HTML5, CSS, JavaScript [ES6] and Other Front-End TechnologiesjQuery, Bootstrap, ReactJS, AngularJS, VueJSNode JS [Good to have]Responsive Design, Cross-Platform [Web and Mobile], Cross-Browser Environment compatibility, Object-Oriented Design, Web Services (REST/SOAP)Web Services (Restful/Any web services)-Consumption experience is fineExperience With Git, BitbucketKnowledgeable of REST-Based APIsKnowledgeable of Web Application Development FrameworksManage and Prioritize Project WorkKnowledge in MariaDB, or at least should have knowledge in RMDB (e.g, MySQL, Oracle)Preferable to have knowledge in Private Cloud platform (Openshift, Kubernetes, Docker)AWS [Good to Have]Hadoop: Hive/Impala/Spark [Good to Have]Any NoSQL Database [DynamoDB, MongoDB, CASSANDRA, HBase, etc…][Good to Have]Familiar with Agile practiceEstablish Continuous integration and Release automationGood Communication and Troubleshooting skills AngularReactJSJava 8JavaScriptUnit TestingRest API

Signals

Skill full-stack-engineer
0.37
Alias full-stack-engineer
1.00
KRA full-stack-engineer
0.50
Status: completed Created: 2026-05-27T14:34:55.949349Z Updated: 2026-06-12T17:32:12.958841Z API 3 duration: 204906 ms
Flow Current 3-step pipeline

1 POST /skills/extract-from-jd

2 POST /skills/extract-details

3 POST /skills/final-role-output

Role Chosen role & resolution

Fullstack Developer

CASE A

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

Multi-alias tie (3 roles at 1.0) resolved by TIER_A_KRA: Fullstack Developer

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 are looking for Java Full Stack Developers with experience in building highperforming, scalable, enterprise-grade applications. Resource will be part of a talented software team that works on mission-critical treasury applications. Resource will be responsible for designing & development of the Treasury Applications while providing expertise in the full software development lifecycle, from concept and design to testing.

Responsibilities
Collaborate with product owners and architects on making design decisions.Development of end user application with high scalability and high throughput.Provide technical and design guidance and create standards.Improve, optimize and identify opportunities for improved software development processes.Expertise in designing enterprise applications

Requirements
Working experience on Java 8 (Good to have 9/10/11)Springboot microservices, Spring (spring security, spring integration, spring batch, spring data, spring cloud, spring boot)JPA (Java Persistent API), Hibernate, MyBatisUnix/Linux-Any Unix flavorSQL/Database knowledge/Performance-TuningAny messaging knowledge [JMS, KAFKA]HTML5, CSS, JavaScript [ES6] and Other Front-End TechnologiesjQuery, Bootstrap, ReactJS, AngularJS, VueJSNode JS [Good to have]Responsive Design, Cross-Platform [Web and Mobile], Cross-Browser Environment compatibility, Object-Oriented Design, Web Services (REST/SOAP)Web Services (Restful/Any web services)-Consumption experience is fineExperience With Git, BitbucketKnowledgeable of REST-Based APIsKnowledgeable of Web Application Development FrameworksManage and Prioritize Project WorkKnowledge in MariaDB, or at least should have knowledge in RMDB (e.g, MySQL, Oracle)Preferable to have knowledge in Private Cloud platform (Openshift, Kubernetes, Docker)AWS [Good to Have]Hadoop: Hive/Impala/Spark [Good to Have]Any NoSQL Database [DynamoDB, MongoDB, CASSANDRA, HBase, etc…][Good to Have]Familiar with Agile practiceEstablish Continuous integration and Release automationGood Communication and Troubleshooting skillsMinimum experience required 2- 5 years

Technologies
AngularReactJSJava 8JavaScriptUnit TestingRest API

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 ClubsHybrid Work Model Soft loans to set up workspace at home Stable workload Relocation opportunities with ‘EPAM without Borders’ programCertification 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

Skills from this JD

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

Java Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Java id=1 · java

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Java Language and JVM Catalog dimension db id 279

    Library dimension (catalog)

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

  • Kotlin and Java Catalog dimension db id 161

    Library dimension (catalog)

    Roles linked in library: Android Developer

  • Native Mobile Languages Catalog dimension db id 274

    Library dimension (catalog)

    Roles linked in library: Native Mobile Developer

  • Pega Programming Languages & DSLs Catalog dimension db id 267

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

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

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

API 3 link attempts (this skill)

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

Aliases — catalog

  • Spring Boot (CANONICAL) primary
  • SB2 (VERSION)
  • SB3 (VERSION)
  • Spring Boot 2 (VERSION)
  • Spring Boot 2.x (VERSION)
  • Spring Boot 3 (VERSION)
  • Spring Boot 3.x (VERSION)
  • boot2 (VERSION)
  • boot3 (VERSION)

Context tags (catalog)

Actuator Dependency Injection Docker Embedded Tomcat Gradle Hibernate JPA JUnit Java EE Kafka Kubernetes Maven Microservices REST APIs RESTful RESTful API Spring Cloud Spring Data Spring Data JPA Spring MVC Spring Security Thymeleaf WebFlux application.properties dependency injection microservices

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Backend Framework
Vendor
Pivotal Software
License
apache_2
Year introduced
2014
Confidence
0.99
Version strategy
SEPARATE_ENTITY
Version tag
3.x

Maturity reasoning: Spring Boot appears in a large volume of backend Java job descriptions and is the default Spring stack for new services; Spring’s own docs and ecosystem center on Boot for production apps.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Web Application Frameworks Catalog dimension db id 2

    Library dimension (catalog)

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

  • Web Service Frameworks Catalog dimension db id 390

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Web Application Frameworks
web-application-frameworks
Existing dimension (library) · Role↔dimension saved
Web Service Frameworks
web-service-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Spring Security Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Spring Security id=2234 · spring-security

Aliases — catalog

  • Spring Security (CANONICAL) primary
  • Spring Security 4 (VERSION)
  • Spring Security 4.x (VERSION)
  • Spring Security 5 (VERSION)
  • Spring Security 5.x (VERSION)
  • Spring Security 6 (VERSION)
  • Spring Security 6.x (VERSION)
  • spring-security 5 (VERSION)
  • spring-security 6 (VERSION)

Context tags (catalog)

CSRF JWT LDAP OAuth2 RESTful services Spring Boot authentication authorization custom authentication custom security filter chain method security role-based access security configuration security context security filters web security

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Security Framework
Vendor
Pivotal Software
License
apache_2
Year introduced
2003
Confidence
0.96
Version strategy
SEPARATE_ENTITY
Version tag
6.x

Maturity reasoning: Commonly listed in Java/Spring backend job descriptions for authN/authZ, SSO, and OAuth2/OIDC; it remains the standard security layer in the Spring ecosystem rather than a niche add-on.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Authentication and Authorization Catalog dimension db id 6

    Library dimension (catalog)

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

  • Backend Authentication and Authorization Catalog dimension db id 386

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Authentication and Authorization
authentication-and-authorization
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Backend Authentication and Authorization
backend-authentication-and-authorization
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Spring Integration Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Web Frameworks
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Spring Batch Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Web Frameworks
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Spring Data Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Spring Data id=3557 · spring-data

Aliases — catalog

  • Spring Data (CANONICAL) primary

Context tags (catalog)

CRUD Hibernate JPA MongoDB Spring Boot Spring Data REST auditing criteria queries data mapping data sources pagination projection query methods repositories transaction management

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Data Access Framework
Vendor
Pivotal Software
License
apache_2
Year introduced
2011
Confidence
0.95
Version strategy
NOT_APPLICABLE

Maturity reasoning: Spring Data appears in many Java/Spring job descriptions and is a standard data-access layer in the Spring ecosystem, with broad adoption across enterprise backend roles.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • ORMs and Data Access Layers Catalog dimension db id 5

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
ORMs and Data Access Layers
orms-and-data-access-layers
Existing dimension (library) · Role↔dimension saved
Spring Cloud Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Web Frameworks
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
JPA Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: JPA id=2196 · jpa

Aliases — catalog

  • JPA (CANONICAL) primary

Context tags (catalog)

Criteria API EntityManager Hibernate JPA provider JPQL ORM Spring Data JPA annotations caching cascading database migrations database schema fetch strategies lazy loading mapping persistence.xml repositories transactions

Stored enrichment (catalog DB)

Category
Standard
Sub-category
Persistence Specification
Vendor
Eclipse Foundation
License
other_open
Year introduced
2006
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: JPA appears frequently in Java backend job descriptions and remains the standard ORM/persistence spec in the Spring/Hibernate ecosystem, with no vendor sunset or replacement announced.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Application ORM and Repository-Based Data Access Catalog dimension db id 459

    Library dimension (catalog)

    Roles linked in library: Scala Backend Developer

  • ORMs and Data Access Layers Catalog dimension db id 5

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Application ORM and Repository-Based Data Access
application-orm-and-repository-based-data-access
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ORMs and Data Access Layers
orms-and-data-access-layers
Existing dimension (library) · Role↔dimension saved
Hibernate Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Hibernate id=21 · hibernate

Aliases — catalog

  • Hibernate (CANONICAL) primary

Context tags (catalog)

C3P0 Criteria API EntityManager HQL Hibernate Validator JPA JPQL ORM SQL Spring Spring Data Spring Data JPA annotations caching cascade criteria criteria API database dialect entity fetching first-level cache flush lazy loading mapping mapping files mappings merge persistence persistence context second-level cache session session factory transaction transaction management transactions

Stored enrichment (catalog DB)

Category
Library
Sub-category
Orm Library
Vendor
Red Hat
License
gpl_v2
Year introduced
2001
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Hibernate remains a common Java ORM in enterprise job postings and is still widely used in Spring/JPA stacks; no vendor sunset or clear replacement has displaced it.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Application ORM and Repository-Based Data Access Catalog dimension db id 459

    Library dimension (catalog)

    Roles linked in library: Scala Backend Developer

  • ORMs and Data Access Layers Catalog dimension db id 5

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Application ORM and Repository-Based Data Access
application-orm-and-repository-based-data-access
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ORMs and Data Access Layers
orms-and-data-access-layers
Existing dimension (library) · Role↔dimension saved
MyBatis Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Data Engineering Tools
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Linux Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Operating Systems
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
Unix Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Operating Systems
Sub-category
general
Skill nature
CONCEPT
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
UNVERSIONED
SQL Primary 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 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 for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JMS Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Messaging Systems
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Kafka Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Kafka id=36 · kafka

Aliases — catalog

  • Kafka (CANONICAL) primary

Context tags (catalog)

Apache Flink Apache Kafka Apache Pulsar Apache Spark Avro KSQL Kafka API Kafka Connect Kafka Streams ZooKeeper Zookeeper backpressure brokers consumer consumer group consumer groups event sourcing event-driven architecture exactly-once semantics fault tolerance high throughput log compaction message broker message queue microservices offsets partition partitioning partitions producer producer API real-time analytics real-time data replication schema registry stream processing topic topic partitioning topics

Stored enrichment (catalog DB)

Category
Datastore
Sub-category
Event Stream Store
Vendor
Confluent
License
apache_2
Year introduced
2011
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: Kafka appears in many production JDs for event streaming and data pipelines, and remains a standard platform in cloud/vendor offerings (e.g., Confluent, AWS MSK), indicating broad hiring demand.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Asynchronous Messaging and Event Streaming Catalog dimension db id 297

    Library dimension (catalog)

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

  • Messaging and Background Jobs Catalog dimension db id 291

    Library dimension (catalog)

    Roles linked in library: PHP Backend Developer, Python Backend Developer, Ruby Backend Developer

  • Messaging and Event Streaming Catalog dimension db id 8

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Data Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Asynchronous Messaging and Event Streaming
asynchronous-messaging-and-event-streaming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Messaging and Background Jobs
messaging-and-background-jobs
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Messaging and Event Streaming
messaging-and-event-streaming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTML5 Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: HTML5 id=3087 · html5

Aliases — catalog

  • HTML5 (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Web Standards & Compliance Catalog dimension db id 343

    Library dimension (catalog)

    Roles linked in library: WordPress Dev

API 3 link attempts (this skill)

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

Aliases — catalog

  • CSS (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • CSS Architecture and Styling Catalog dimension db id 117

    Library dimension (catalog)

    Roles linked in library: Frontend Developer, Fullstack Developer, 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)
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 & Template Languages Catalog dimension db id 359

    Library dimension (catalog)

    Roles linked in library: Drupal Dev

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Storefront JavaScript and DOM Behavior Catalog dimension db id 422

    Library dimension (catalog)

    Roles linked in library: Shopify Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript for WordPress
javascript-for-wordpress
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
Programming Languages & 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)
ES6 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 & Template Languages Catalog dimension db id 359

    Library dimension (catalog)

    Roles linked in library: Drupal Dev

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Storefront JavaScript and DOM Behavior Catalog dimension db id 422

    Library dimension (catalog)

    Roles linked in library: Shopify Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript for WordPress
javascript-for-wordpress
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
Programming Languages & 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)
jQuery Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: jQuery id=1968 · jquery

Aliases — catalog

  • jQuery (CANONICAL) primary

Context tags (catalog)

$.ajax() $.getJSON() AJAX DOM manipulation JSON JSON parsing UI components animations callback functions chaining cross-browser deferred deferred objects deferreds event handling jQuery Mobile jQuery UI lightweight minification mobile support mobile-first plugins responsive design selecting elements selectors

Stored enrichment (catalog DB)

Category
Library
Sub-category
Javascript Library
Vendor
jQuery Foundation
License
mit
Year introduced
2006
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: jQuery still appears in legacy JDs, but modern frontend stacks have largely replaced it with React/Vue/Angular and native DOM APIs; greenfield demand is low and declining.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Application Frameworks & Libraries Catalog dimension db id 451

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Frameworks & Libraries Catalog dimension db id 360

    Library dimension (catalog)

    Roles linked in library: Drupal Dev

  • JavaScript Checkout Behavior Catalog dimension db id 393

    Library dimension (catalog)

    Roles linked in library: Magento Dev

  • Storefront JavaScript and DOM Behavior Catalog dimension db id 422

    Library dimension (catalog)

    Roles linked in library: Shopify Dev

  • Web UI & Integration Frameworks Catalog dimension db id 268

    Library dimension (catalog)

    Roles linked in library: Pega Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Application Frameworks & Libraries
application-frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Frameworks & Libraries
frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript Checkout Behavior
javascript-checkout-behavior
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)
Web UI & Integration Frameworks
web-ui-integration-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Bootstrap Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Bootstrap id=1970 · bootstrap

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Component Libraries and Design Systems Catalog dimension db id 118

    Library dimension (catalog)

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

  • Web UI & Integration Frameworks Catalog dimension db id 268

    Library dimension (catalog)

    Roles linked in library: Pega Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Component Libraries and Design Systems
component-libraries-and-design-systems
Existing dimension (library) · Role↔dimension saved
Web UI & Integration Frameworks
web-ui-integration-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: React id=610 · react

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Application Frameworks & Libraries Catalog dimension db id 451

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • Frontend Frameworks and Libraries Catalog dimension db id 434

    Library dimension (catalog)

    Roles linked in library: Shopify Dev

  • JavaScript for WordPress Catalog dimension db id 329

    Library dimension (catalog)

    Roles linked in library: WordPress Dev

  • React Component Architecture Catalog dimension db id 302

    Library dimension (catalog)

    Roles linked in library: React Frontend Developer

  • UI Frameworks and Rendering Catalog dimension db id 115

    Library dimension (catalog)

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

API 3 link attempts (this skill)

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

Aliases — catalog

  • Angular (CANONICAL) primary
  • Angular 1 (VERSION)
  • Angular 1.x (VERSION)
  • Angular 10 (VERSION)
  • Angular 11 (VERSION)
  • Angular 12 (VERSION)
  • Angular 13 (VERSION)
  • Angular 14 (VERSION)
  • Angular 15 (VERSION)
  • Angular 16 (VERSION)
  • Angular 17 (VERSION)
  • Angular 2 (VERSION)
  • Angular 2+ (VERSION)
  • Angular 4 (VERSION)
  • Angular 5 (VERSION)
  • Angular 6 (VERSION)
  • Angular 7 (VERSION)
  • Angular 8 (VERSION)
  • Angular 9 (VERSION)
  • AngularJS (VERSION)
  • angular 1 (VERSION)
  • angular 1.x (VERSION)
  • angular 10 (VERSION)
  • angular 11 (VERSION)
  • angular 12 (VERSION)
  • angular 13 (VERSION)
  • angular 14 (VERSION)
  • angular 15 (VERSION)
  • angular 16 (VERSION)
  • angular 17 (VERSION)
  • angular 18 (VERSION)
  • angular 19 (VERSION)
  • angular 2 (VERSION)
  • angular 2+ (VERSION)
  • angular 2.x (VERSION)
  • angular 3 (VERSION)
  • angular 4 (VERSION)
  • angular 5 (VERSION)
  • angular 6 (VERSION)
  • angular 7 (VERSION)
  • angular 8 (VERSION)
  • angular 9 (VERSION)
  • angular17 (VERSION)
  • angular2 (VERSION)
  • angularjs (VERSION)
  • angularjs 1.x (VERSION)
  • ng (VERSION)
  • ng1 (VERSION)
  • ng2 (VERSION)

Context tags (catalog)

AOT Angular CLI Angular Material Component Dependency Injection Directive NgRx Observable Observables PWA RESTful services Reactive Forms Routing RxJS Service Single Page Application TypeScript Unit Testing component-based components dependency injection directives lazy loading modules observables pipes responsive design routing services single-page application single-page applications templates two-way data binding unit testing

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Frontend Framework
Vendor
Google
License
mit
Year introduced
2010
Confidence
0.98
Version strategy
SEPARATE_ENTITY
Version tag
2+

Maturity reasoning: Angular remains widely listed in frontend job descriptions and enterprise stacks; Google continues maintaining Angular, and it is a common hiring-pipeline skill alongside React/Vue rather than a sunset technology.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Angular Component Model and Templates Catalog dimension db id 303

    Library dimension (catalog)

    Roles linked in library: Angular Frontend Developer

  • Application Frameworks & Libraries Catalog dimension db id 451

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

  • UI Frameworks and Rendering Catalog dimension db id 115

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Angular Component Model and Templates
angular-component-model-and-templates
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Application Frameworks & Libraries
application-frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension saved
Vue.js Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Vue.js id=3201 · vue-js

Aliases — catalog

  • Vue.js (CANONICAL) primary
  • vue (VERSION)
  • vue 2 (VERSION)
  • vue 2.x (VERSION)
  • vue 3 (VERSION)
  • vue 3.x (VERSION)
  • vue.js 2 (VERSION)
  • vue.js 3 (VERSION)
  • vue.js2 (VERSION)
  • vue.js@3 (VERSION)
  • vue2 (VERSION)
  • vue2.x (VERSION)
  • vue3 (VERSION)
  • vuejs 3 (VERSION)
  • vuejs3 (VERSION)

Context tags (catalog)

Component Lifecycle Composition API Directives Event Handling Mixins Nuxt.js Reactive Data Scoped Slots Server-Side Rendering Single File Components State Management Vue 3 Vue CLI Vue Devtools Vue Router Vuex

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Frontend Framework
Vendor
Evan You
License
mit
Year introduced
2014
Confidence
0.98
Version strategy
SEPARATE_ENTITY
Version tag
3

Maturity reasoning: Vue.js appears in many frontend job postings and is a common alternative to React/Angular; its ecosystem and Vue 3 adoption show sustained market demand rather than niche use.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Frameworks & Libraries Catalog dimension db id 360

    Library dimension (catalog)

    Roles linked in library: Drupal Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Frameworks & Libraries
frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Node.js Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Node.js id=1564 · node-js

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • JavaScript and TypeScript Catalog dimension db id 114

    Library dimension (catalog)

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

  • Web Application Frameworks Catalog dimension db id 2

    Library dimension (catalog)

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

API 3 link attempts (this skill)

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

Aliases — catalog

  • REST (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • API Design and Contracts Catalog dimension db id 3

    Library dimension (catalog)

    Roles linked in library: Backend Developer, Fullstack Developer

  • API Interface and Contract Design Catalog dimension db id 289

    Library dimension (catalog)

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

  • Integration Protocols & Standards Catalog dimension db id 271

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Standards & Protocols Compliance Catalog dimension db id 452

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

API 3 link attempts (this skill)

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

Aliases — catalog

  • SOAP (CANONICAL) primary

Context tags (catalog)

API Apache CXF Axis2 Binding Endpoint Envelope Fault Fault Handling HTTP Interoperability JAX-WS Message Message Exchange Message Exchange Pattern REST RPC SOAP 1.1 SOAP 1.2 SOAP API SOAP Envelope SOAP Fault SOAP Header SOAP UI SOAP client SOAP envelope SOAP message SOAP server SOAPAction SOAPUI Security Service Contract Service-Oriented Architecture Service-oriented Architecture Transport Protocols UDDI WS-Addressing WS-Security WSDL Web Services Web Services Security XML XML Schema XSD binding endpoint fault handling message exchange pattern serialization service-oriented architecture transport protocol web services

Stored enrichment (catalog DB)

Category
Protocol
Sub-category
Api Protocol
Year introduced
1998
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: SOAP still appears in enterprise/legacy integration JDs, but far less than REST/GraphQL; many vendors and docs position REST/JSON as the default for new APIs, indicating a narrow, legacy-heavy market signal.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • External System Integrations Catalog dimension db id 14

    Library dimension (catalog)

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

  • Integration Protocols & Standards Catalog dimension db id 271

    Library dimension (catalog)

    Roles linked in library: Pega Developer

  • Standards & Protocols Compliance Catalog dimension db id 452

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
External System Integrations
external-system-integrations
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Integration Protocols & Standards
integration-protocols-standards
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Standards & Protocols Compliance
standards-protocols-compliance
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Git Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Git id=1002 · git

Aliases — catalog

  • Git (CANONICAL)

Context tags (catalog)

CI/CD GitHub GitLab branching checkout clone commit fork merging pull request rebase remote repository stash versioning

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Version Control Tool
Vendor
Linus Torvalds
License
gpl_v2
Year introduced
2005
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Git is a hiring-pipeline staple: it appears in the vast majority of software engineering job descriptions and is the default VCS on GitHub/GitLab/Bitbucket.

Skill profile (library / DB)

Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
13
Sub-category id
730
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)
Bitbucket Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Version Control Systems
Sub-category
general
Skill nature
PLATFORM
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
MariaDB Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Databases
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
MySQL Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: MySQL id=17 · mysql

Aliases — catalog

  • MySQL (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Relational Data Modeling Catalog dimension db id 216

    Library dimension (catalog)

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

  • Relational Database Design Catalog dimension db id 4

    Library dimension (catalog)

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

  • Relational Database Usage Catalog dimension db id 371

    Library dimension (catalog)

    Roles linked in library: Go Backend Developer

API 3 link attempts (this skill)

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

Aliases — catalog

  • Oracle Database (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Relational Database Design Catalog dimension db id 4

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Relational Database Design
relational-database-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
OpenShift 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
Container Orchestration
Sub-category
general
Skill nature
PLATFORM
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Kubernetes Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Kubernetes id=726 · kubernetes

Aliases — catalog

  • Kubernetes (CANONICAL) primary
  • Kubernetes 1.0+ (VERSION)
  • Kubernetes 1.x (VERSION)
  • Kubernetes v1 (VERSION)
  • k8s (VERSION)
  • kubernetes 1.x (VERSION)
  • kubernetes latest (VERSION)

Context tags (catalog)

CI/CD Cluster Autoscaler ConfigMap DaemonSet Deployment Docker Grafana Helm Ingress Istio K8s Kubelet Namespace Pod Prometheus RBAC Secret Service StatefulSet containerization deployment etcd kubectl load balancing microservices namespace orchestration persistent storage scalability service mesh

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Container Orchestration Platform
Vendor
Cloud Native Computing Foundation
License
apache_2
Year introduced
2014
Confidence
0.90
Version strategy
SEPARATE_ENTITY
Version tag
1.30

Maturity reasoning: Broadly adopted in cloud-native stacks; Kubernetes appears in a large share of DevOps/SRE job descriptions and is the default orchestration platform across major cloud vendors.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Container Orchestration Platforms Catalog dimension db id 134

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

  • Kubernetes for ML Workloads Catalog dimension db id 47

    Library dimension (catalog)

    Roles linked in library: ML Engineer, MLOps Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Container Orchestration Platforms
container-orchestration-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubernetes for ML Workloads
kubernetes-for-ml-workloads
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Docker id=61 · docker

Aliases — catalog

  • Docker (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Containerization and Image Builds Catalog dimension db id 152

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Deployment and Cloud Platforms Catalog dimension db id 418

    Library dimension (catalog)

    Roles linked in library: Ruby Backend Developer

  • Deployment and Runtime Configuration Catalog dimension db id 13

    Library dimension (catalog)

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

API 3 link attempts (this skill)

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

Aliases — catalog

  • AWS (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

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

  • Cloud Platforms for AI Deployment Catalog dimension db id 211

    Library dimension (catalog)

    Roles linked in library: AI Engineer

  • Cloud Provider Platforms Catalog dimension db id 131

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, Cloud Security Engineer

  • Cloud Security Posture Tools Catalog dimension db id 64

    Library dimension (catalog)

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

API 3 link attempts (this skill)

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

Aliases — catalog

  • Hive (CANONICAL) primary

Context tags (catalog)

Apache Apache Hive Bucketing ETL HQL Hive Metastore Hive SerDe HiveQL MapReduce SQL SQL-on-Hadoop big data bucketing columnar storage data lakes data warehousing integration metadata partitioning schema evolution

Stored enrichment (catalog DB)

Category
Datastore
Sub-category
Local Key Value Store
Vendor
Apache Software Foundation
License
apache_2
Year introduced
2010
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: Hive appears in Flutter/mobile JDs and package docs, but JD volume is far below SQLite/Realm and it’s mainly used for local key-value storage in Flutter apps.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Local Persistence and Offline Behavior Catalog dimension db id 85

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Local Persistence and Offline Behavior
local-persistence-and-offline-behavior
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Impala 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
Databases
Sub-category
general
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Spark Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Apache Spark id=1350 · apache-spark

Aliases — catalog

  • Apache Spark (CANONICAL)
  • apache spark 3 (VERSION)
  • spark (VERSION)
  • spark 3 (VERSION)
  • spark 3.x (VERSION)
  • spark3 (VERSION)

Context tags (catalog)

Apache Kafka Cluster Manager DAGScheduler Data Lake DataFrame ETL Hadoop MLlib Machine Learning PySpark RDD Scala Spark SQL Spark Streaming SparkSession

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Distributed Data Processing Framework
Vendor
Apache Software Foundation
License
apache_2
Year introduced
2010
Confidence
0.94
Version strategy
SEPARATE_ENTITY
Version tag
3.x

Maturity reasoning: Apache Spark appears in many data engineering JDs and remains a standard for distributed ETL/ELT; its GitHub and vendor ecosystem activity stay strong, with Databricks and cloud platforms still promoting it.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • ETL and ELT Tooling Catalog dimension db id 24

    Library dimension (catalog)

    Roles linked in library: Data Engineer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
ETL and ELT Tooling
etl-and-elt-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DynamoDB Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Amazon DynamoDB id=93 · amazon-dynamodb

Aliases — catalog

  • Amazon DynamoDB (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • NoSQL Databases Catalog dimension db id 19

    Library dimension (catalog)

    Roles linked in library: Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
NoSQL Databases
nosql-databases
Skipped — no persistable v3 meta for new skill
skill_not_in_db_v3_proposed
MongoDB Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: MongoDB id=91 · mongodb

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • NoSQL Databases Catalog dimension db id 19

    Library dimension (catalog)

    Roles linked in library: Backend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
NoSQL Databases
nosql-databases
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cassandra Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Cassandra id=1354 · cassandra

Aliases — catalog

  • Cassandra (CANONICAL)

Context tags (catalog)

CQL Cluster Consistency DSE Data Modeling DataStax Eventual Consistency NoSQL Partitioning Replication ScyllaDB Spark Thrift TinkerPop Wide Column

Stored enrichment (catalog DB)

Category
Datastore
Sub-category
Wide Column Store
Vendor
Apache Software Foundation
License
apache_2
Year introduced
2008
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Apache Cassandra appears in many production data-platform JDs and is a common choice for high-write, distributed workloads; GitHub and vendor docs show sustained activity rather than sunset signals.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cloud Storage and Data Services Catalog dimension db id 144

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Storage and Data Services
cloud-storage-and-data-services
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HBase Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: HBase id=1352 · hbase

Aliases — catalog

  • HBase (CANONICAL)

Context tags (catalog)

Apache Bigtable Hadoop MapReduce NoSQL REST API Thrift column family data model data replication distributed real-time region server scalability table design

Stored enrichment (catalog DB)

Category
Datastore
Sub-category
Wide Column Store
Vendor
Apache Software Foundation
License
apache_2
Year introduced
2010
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: HBase appears in a limited set of big-data/legacy Hadoop job postings, while newer JDs more often specify DynamoDB, Bigtable, or Cassandra; its market demand is specialized rather than broad.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cloud Storage and Data Services Catalog dimension db id 144

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cloud Storage and Data Services
cloud-storage-and-data-services
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Agile Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Agile id=520 · agile

Aliases — catalog

  • Agile (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Agile
Confidence
0.99
Version strategy
NOT_APPLICABLE

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Continuous Integration Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Practices
Sub-category
general
Skill nature
PRACTICE
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Release Automation Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Practices
Sub-category
general
Skill nature
PRACTICE
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
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)

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
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 saved
Java in_db
Programming Languages for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Spring Boot in_db
Web Application Frameworks
web-application-frameworks
Existing dimension (library) · Role↔dimension saved
Spring Boot in_db
Web Service Frameworks
web-service-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Spring Security in_db
Authentication and Authorization
authentication-and-authorization
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Spring Security in_db
Backend Authentication and Authorization
backend-authentication-and-authorization
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Spring Data in_db
ORMs and Data Access Layers
orms-and-data-access-layers
Existing dimension (library) · Role↔dimension saved
JPA in_db
Application ORM and Repository-Based Data Access
application-orm-and-repository-based-data-access
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JPA in_db
ORMs and Data Access Layers
orms-and-data-access-layers
Existing dimension (library) · Role↔dimension saved
Hibernate in_db
Application ORM and Repository-Based Data Access
application-orm-and-repository-based-data-access
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Hibernate in_db
ORMs and Data Access Layers
orms-and-data-access-layers
Existing dimension (library) · Role↔dimension saved
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 for Data Work
programming-languages-for-data-work
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kafka in_db
Asynchronous Messaging and Event Streaming
asynchronous-messaging-and-event-streaming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kafka in_db
Messaging and Background Jobs
messaging-and-background-jobs
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kafka in_db
Messaging and Event Streaming
messaging-and-event-streaming
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HTML5 in_db
Web Standards & Compliance
web-standards-compliance
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CSS in_db
CSS Architecture and Styling
css-architecture-and-styling
Existing dimension (library) · Role↔dimension saved
CSS in_db
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CSS in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CSS in_db
Storefront Styling and Responsive Layout
storefront-styling-and-responsive-layout
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CSS in_db
Styling and Responsive Layout
styling-and-responsive-layout
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
JavaScript for WordPress
javascript-for-wordpress
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
JavaScript in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
JavaScript in_db
Programming Languages & 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)
ES6 in_db
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ES6 in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ES6 in_db
JavaScript for WordPress
javascript-for-wordpress
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ES6 in_db
Pega Programming Languages & DSLs
pega-programming-languages-dsls
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ES6 in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension saved
ES6 in_db
Programming Languages & Template Languages
programming-languages-template-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ES6 in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
ES6 in_db
Storefront JavaScript and DOM Behavior
storefront-javascript-and-dom-behavior
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
jQuery in_db
Application Frameworks & Libraries
application-frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
jQuery in_db
Frameworks & Libraries
frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
jQuery in_db
JavaScript Checkout Behavior
javascript-checkout-behavior
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
jQuery in_db
Storefront JavaScript and DOM Behavior
storefront-javascript-and-dom-behavior
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
jQuery in_db
Web UI & Integration Frameworks
web-ui-integration-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Bootstrap in_db
Component Libraries and Design Systems
component-libraries-and-design-systems
Existing dimension (library) · Role↔dimension saved
Bootstrap in_db
Web UI & Integration Frameworks
web-ui-integration-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
Application Frameworks & Libraries
application-frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
Frontend Frameworks and Libraries
frontend-frameworks-and-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
JavaScript for WordPress
javascript-for-wordpress
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
React Component Architecture
react-component-architecture
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React in_db
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension saved
AngularJS in_db
Angular Component Model and Templates
angular-component-model-and-templates
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AngularJS in_db
Application Frameworks & Libraries
application-frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AngularJS in_db
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension saved
Vue.js in_db
Frameworks & Libraries
frameworks-libraries
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Node.js in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Node.js in_db
Web Application Frameworks
web-application-frameworks
Existing dimension (library) · Role↔dimension saved
REST in_db
API Design and Contracts
api-design-and-contracts
Existing dimension (library) · Role↔dimension saved
REST in_db
API Interface and Contract Design
api-interface-and-contract-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
Integration Protocols & Standards
integration-protocols-standards
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
REST in_db
Standards & Protocols Compliance
standards-protocols-compliance
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SOAP in_db
External System Integrations
external-system-integrations
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SOAP in_db
Integration Protocols & Standards
integration-protocols-standards
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
SOAP in_db
Standards & Protocols Compliance
standards-protocols-compliance
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Git in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MySQL in_db
Relational Data Modeling
relational-data-modeling
Existing dimension (library) · Role↔dimension saved
MySQL in_db
Relational Database Design
relational-database-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
MySQL in_db
Relational Database Usage
relational-database-usage
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Oracle Database in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Oracle Database in_db
Relational Database Design
relational-database-design
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubernetes in_db
Container Orchestration Platforms
container-orchestration-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kubernetes in_db
Kubernetes for ML Workloads
kubernetes-for-ml-workloads
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker in_db
Containerization and Image Builds
containerization-and-image-builds
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker in_db
Deployment and Cloud Platforms
deployment-and-cloud-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Docker in_db
Deployment and Runtime Configuration
deployment-and-runtime-configuration
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Cloud Platforms
cloud-platforms
Existing dimension (library) · Role↔dimension saved
AWS in_db
Cloud Platforms for AI Deployment
cloud-platforms-for-ai-deployment
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Cloud Provider Platforms
cloud-provider-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
AWS in_db
Cloud Security Posture Tools
cloud-security-posture-tools
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Hive in_db
Local Persistence and Offline Behavior
local-persistence-and-offline-behavior
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Spark in_db
ETL and ELT Tooling
etl-and-elt-tooling
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
DynamoDB new
NoSQL Databases
nosql-databases
Skipped — no persistable v3 meta for new skill skill_not_in_db_v3_proposed
MongoDB in_db
NoSQL Databases
nosql-databases
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Cassandra in_db
Cloud Storage and Data Services
cloud-storage-and-data-services
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
HBase in_db
Cloud Storage and Data Services
cloud-storage-and-data-services
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Agile in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Unit Testing in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)

Library artifacts (this run)

Kind Detail DB id
canonical_skill_proposed Spring Integration | type=Web Frameworks subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed Spring Batch | type=Web Frameworks subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed Spring Cloud | type=Web Frameworks subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed MyBatis | type=Data Engineering Tools subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed Linux | type=Operating Systems subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed Unix | type=Operating Systems subtype=general nature=CONCEPT lifespan=EVERGREEN
canonical_skill_proposed JMS | type=Messaging Systems subtype=general nature=CONCEPT lifespan=MULTI_YEAR
canonical_skill_proposed Bitbucket | type=Version Control Systems subtype=general nature=PLATFORM lifespan=MULTI_YEAR
canonical_skill_proposed MariaDB | type=Databases subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed OpenShift | type=Container Orchestration subtype=general nature=PLATFORM lifespan=MULTI_YEAR
canonical_skill_proposed Impala | type=Databases subtype=general nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed Continuous Integration | type=Practices subtype=general nature=PRACTICE lifespan=MULTI_YEAR
canonical_skill_proposed Release Automation | type=Practices subtype=general nature=PRACTICE lifespan=MULTI_YEAR
dimension_skill_link_proposed DynamoDB ↔ NoSQL Databases
nano JD Parser — gpt-4.1-nano click to toggle
RoleJava Full Stack Developer
CompanyEPAM
ExperienceMinimum experience required 2- 5 years
DomainIT Services & Consulting
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": {
    "source_marker": {
      "first_5_words": "We offer Insurance Coverage Paid",
      "last_5_words": "career progression tool"
    },
    "text": "We offer Insurance Coverage Paid Leaves \u2013 including maternity, bereavement, paternity, and special COVID-19 leaves. Financial assistance for medical crisis Retiral Benefits \u2013 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 \u2018EPAM without Borders\u2019 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",
    "word_count": 64
  },
  "certifications": [],
  "company_name": "EPAM",
  "ctc": null,
  "domain": {
    "primary": {
      "aliases": [
        "ITES",
        "BPO"
      ],
      "domain": "IT Services \u0026 Consulting"
    },
    "secondary": null
  },
  "education": [],
  "experience": {
    "max": 5,
    "min": 2,
    "raw": "Minimum experience required 2- 5 years"
  },
  "job_locations": [],
  "role": "Java Full Stack Developer",
  "role_aliases": [
    "Full Stack Developer",
    "Java Developer",
    "Software Engineer"
  ],
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 0,
      "heading": "Responsibilities",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Collaborate with product owners and",
        "last_5_words": "designing enterprise applications"
      },
      "text": "Collaborate with product owners and architects on making design decisions.Development of end user application with high scalability and high throughput.Provide technical and design guidance and create standards.Improve, optimize and identify opportunities for improved software development processes.Expertise in designing enterprise applications",
      "word_count": 51
    },
    {
      "bullet_count": 0,
      "heading": "Requirements",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Working experience on Java 8",
        "last_5_words": "and Troubleshooting skills"
      },
      "text": "Working experience on Java 8 (Good to have 9/10/11)Springboot microservices, Spring (spring security, spring integration, spring batch, spring data, spring cloud, spring boot)JPA (Java Persistent API), Hibernate, MyBatisUnix/Linux-Any Unix flavorSQL/Database knowledge/Performance-TuningAny messaging knowledge [JMS, KAFKA]HTML5, CSS, JavaScript [ES6] and Other Front-End TechnologiesjQuery, Bootstrap, ReactJS, AngularJS, VueJSNode JS [Good to have]Responsive Design, Cross-Platform [Web and Mobile], Cross-Browser Environment compatibility, Object-Oriented Design, Web Services (REST/SOAP)Web Services (Restful/Any web services)-Consumption experience is fineExperience With Git, BitbucketKnowledgeable of REST-Based APIsKnowledgeable of Web Application Development FrameworksManage and Prioritize Project WorkKnowledge in MariaDB, or at least should have knowledge in RMDB (e.g, MySQL, Oracle)Preferable to have knowledge in Private Cloud platform (Openshift, Kubernetes, Docker)AWS [Good to Have]Hadoop: Hive/Impala/Spark [Good to Have]Any NoSQL Database [DynamoDB, MongoDB, CASSANDRA, HBase, etc\u2026][Good to Have]Familiar with Agile practiceEstablish Continuous integration and Release automationGood Communication and Troubleshooting skills",
      "word_count": 309
    },
    {
      "bullet_count": 0,
      "heading": "Technologies",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "AngularReactJSJava 8JavaScriptUnit TestingRest",
        "last_5_words": "JavaScriptUnit TestingRest API"
      },
      "text": "AngularReactJSJava 8JavaScriptUnit TestingRest API",
      "word_count": 6
    }
  ],
  "urls": []
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "Java"
    },
    {
      "is_primary": true,
      "skill_name": "Spring Boot"
    },
    {
      "is_primary": true,
      "skill_name": "Spring Security"
    },
    {
      "is_primary": true,
      "skill_name": "Spring Integration"
    },
    {
      "is_primary": true,
      "skill_name": "Spring Batch"
    },
    {
      "is_primary": true,
      "skill_name": "Spring Data"
    },
    {
      "is_primary": true,
      "skill_name": "Spring Cloud"
    },
    {
      "is_primary": true,
      "skill_name": "JPA"
    },
    {
      "is_primary": true,
      "skill_name": "Hibernate"
    },
    {
      "is_primary": true,
      "skill_name": "MyBatis"
    },
    {
      "is_primary": true,
      "skill_name": "Linux"
    },
    {
      "is_primary": true,
      "skill_name": "Unix"
    },
    {
      "is_primary": true,
      "skill_name": "SQL"
    },
    {
      "is_primary": true,
      "skill_name": "JMS"
    },
    {
      "is_primary": true,
      "skill_name": "Kafka"
    },
    {
      "is_primary": true,
      "skill_name": "HTML5"
    },
    {
      "is_primary": true,
      "skill_name": "CSS"
    },
    {
      "is_primary": true,
      "skill_name": "JavaScript"
    },
    {
      "is_primary": true,
      "skill_name": "ES6"
    },
    {
      "is_primary": true,
      "skill_name": "jQuery"
    },
    {
      "is_primary": true,
      "skill_name": "Bootstrap"
    },
    {
      "is_primary": true,
      "skill_name": "React"
    },
    {
      "is_primary": true,
      "skill_name": "AngularJS"
    },
    {
      "is_primary": true,
      "skill_name": "Vue.js"
    },
    {
      "is_primary": false,
      "skill_name": "Node.js"
    },
    {
      "is_primary": true,
      "skill_name": "REST"
    },
    {
      "is_primary": true,
      "skill_name": "SOAP"
    },
    {
      "is_primary": true,
      "skill_name": "Git"
    },
    {
      "is_primary": true,
      "skill_name": "Bitbucket"
    },
    {
      "is_primary": true,
      "skill_name": "MariaDB"
    },
    {
      "is_primary": true,
      "skill_name": "MySQL"
    },
    {
      "is_primary": true,
      "skill_name": "Oracle Database"
    },
    {
      "is_primary": false,
      "skill_name": "OpenShift"
    },
    {
      "is_primary": false,
      "skill_name": "Kubernetes"
    },
    {
      "is_primary": false,
      "skill_name": "Docker"
    },
    {
      "is_primary": false,
      "skill_name": "AWS"
    },
    {
      "is_primary": false,
      "skill_name": "Hive"
    },
    {
      "is_primary": false,
      "skill_name": "Impala"
    },
    {
      "is_primary": false,
      "skill_name": "Spark"
    },
    {
      "is_primary": false,
      "skill_name": "DynamoDB"
    },
    {
      "is_primary": false,
      "skill_name": "MongoDB"
    },
    {
      "is_primary": false,
      "skill_name": "Cassandra"
    },
    {
      "is_primary": false,
      "skill_name": "HBase"
    },
    {
      "is_primary": true,
      "skill_name": "Agile"
    },
    {
      "is_primary": true,
      "skill_name": "Continuous Integration"
    },
    {
      "is_primary": true,
      "skill_name": "Release Automation"
    },
    {
      "is_primary": true,
      "skill_name": "Unit Testing"
    }
  ],
  "jd_role": {
    "display_name": "Java Full Stack Developer",
    "rationale": null,
    "role_aliases": [
      "Full Stack Developer",
      "Java Developer",
      "Software Engineer"
    ],
    "role_archetype": "Engineering",
    "slug": ""
  },
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": {
      "source_marker": {
        "first_5_words": "We offer Insurance Coverage Paid",
        "last_5_words": "career progression tool"
      },
      "text": "We offer Insurance Coverage Paid Leaves \u2013 including maternity, bereavement, paternity, and special COVID-19 leaves. Financial assistance for medical crisis Retiral Benefits \u2013 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 \u2018EPAM without Borders\u2019 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",
      "word_count": 64
    },
    "certifications": [],
    "company_name": "EPAM",
    "ctc": null,
    "domain": {
      "primary": {
        "aliases": [
          "ITES",
          "BPO"
        ],
        "domain": "IT Services \u0026 Consulting"
      },
      "secondary": null
    },
    "education": [],
    "experience": {
      "max": 5,
      "min": 2,
      "raw": "Minimum experience required 2- 5 years"
    },
    "job_locations": [],
    "role": "Java Full Stack Developer",
    "role_aliases": [
      "Full Stack Developer",
      "Java Developer",
      "Software Engineer"
    ],
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 0,
        "heading": "Responsibilities",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Collaborate with product owners and",
          "last_5_words": "designing enterprise applications"
        },
        "text": "Collaborate with product owners and architects on making design decisions.Development of end user application with high scalability and high throughput.Provide technical and design guidance and create standards.Improve, optimize and identify opportunities for improved software development processes.Expertise in designing enterprise applications",
        "word_count": 51
      },
      {
        "bullet_count": 0,
        "heading": "Requirements",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Working experience on Java 8",
          "last_5_words": "and Troubleshooting skills"
        },
        "text": "Working experience on Java 8 (Good to have 9/10/11)Springboot microservices, Spring (spring security, spring integration, spring batch, spring data, spring cloud, spring boot)JPA (Java Persistent API), Hibernate, MyBatisUnix/Linux-Any Unix flavorSQL/Database knowledge/Performance-TuningAny messaging knowledge [JMS, KAFKA]HTML5, CSS, JavaScript [ES6] and Other Front-End TechnologiesjQuery, Bootstrap, ReactJS, AngularJS, VueJSNode JS [Good to have]Responsive Design, Cross-Platform [Web and Mobile], Cross-Browser Environment compatibility, Object-Oriented Design, Web Services (REST/SOAP)Web Services (Restful/Any web services)-Consumption experience is fineExperience With Git, BitbucketKnowledgeable of REST-Based APIsKnowledgeable of Web Application Development FrameworksManage and Prioritize Project WorkKnowledge in MariaDB, or at least should have knowledge in RMDB (e.g, MySQL, Oracle)Preferable to have knowledge in Private Cloud platform (Openshift, Kubernetes, Docker)AWS [Good to Have]Hadoop: Hive/Impala/Spark [Good to Have]Any NoSQL Database [DynamoDB, MongoDB, CASSANDRA, HBase, etc\u2026][Good to Have]Familiar with Agile practiceEstablish Continuous integration and Release automationGood Communication and Troubleshooting skills",
        "word_count": 309
      },
      {
        "bullet_count": 0,
        "heading": "Technologies",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "AngularReactJSJava 8JavaScriptUnit TestingRest",
          "last_5_words": "JavaScriptUnit TestingRest API"
        },
        "text": "AngularReactJSJava 8JavaScriptUnit TestingRest API",
        "word_count": 6
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "2f41f803-2392-4fba-bac3-8ea9ed2a2eb1",
  "stage3_signals": {
    "alias_found": true,
    "alias_match_roles": [
      {
        "display_name": "Fullstack Developer",
        "kra_matches": null,
        "matched_count": null,
        "matched_skills": null,
        "role_id": 15,
        "score": 1.0,
        "slug": "full-stack-engineer",
        "total_count": null
      },
      {
        "display_name": "Backend Developer",
        "kra_matches": null,
        "matched_count": null,
        "matched_skills": null,
        "role_id": 1,
        "score": 1.0,
        "slug": "backend-engineer",
        "total_count": null
      },
      {
        "display_name": "Java Backend Developer",
        "kra_matches": null,
        "matched_count": null,
        "matched_skills": null,
        "role_id": 79,
        "score": 1.0,
        "slug": "java-backend-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": "Collaborate with product owners and architects on making design decisions.Development of end user application with high scalability and high throughput.Provide technical and design guidance and create standards.Improve, optimize and identify opportunities for improved software development processes.Expertise in designing enterprise applications",
            "similarity": 0.5724
          },
          {
            "kra_text": "Builds and integrates client-side React or Vue components with server-side Node.js or Django APIs, managing bidirectional data flow across frontend and backend layers.",
            "sentence": "AngularReactJSJava 8JavaScriptUnit TestingRest API",
            "similarity": 0.4622
          },
          {
            "kra_text": "Designs and queries relational databases like PostgreSQL and document stores like MongoDB, writing migrations, indexes, and optimized queries.",
            "sentence": "Working experience on Java 8 (Good to have 9/10/11)Springboot microservices, Spring (spring security, spring integration, spring batch, spring data, spring cloud, spring boot)JPA (Java Persistent API), Hibernate, MyBatisUnix/Linux-Any Unix flavorSQL/Database knowledge/Performance-TuningAny messaging knowledge [JMS, KAFKA]HTML5, CSS, JavaScript [ES6] and Other Front-End TechnologiesjQuery, Bootstrap, ReactJS, AngularJS, VueJSNode JS [Good to have]Responsive Design, Cross-Platform [Web and Mobile], Cross-Browser Environment compatibility, Object-Oriented Design, Web Services (REST/SOAP)Web Services (Restful/Any web services)-Consumption experience is fineExperience With Git, BitbucketKnowledgeable of REST-Based APIsKnowledgeable of Web Application Development FrameworksManage and Prioritize Project WorkKnowledge in MariaDB, or at least should have knowledge in RMDB (e.g, MySQL, Oracle)Preferable to have knowledge in Private Cloud platform (Openshift, Kubernetes, Docker)AWS [Good to Have]Hadoop: Hive/Impala/Spark [Good to Have]Any NoSQL Database [DynamoDB, MongoDB, CASSANDRA, HBase, etc\u2026][Good to Have]Familiar with Agile practiceEstablish Continuous integration and Release automationGood Communication and Troubleshooting skills",
            "similarity": 0.4521
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 15,
        "score": 0.4956,
        "slug": "full-stack-engineer",
        "total_count": null
      },
      {
        "display_name": "Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "Collaborates with UX designers to refine interaction details, animations, responsive breakpoints, and micro-interaction behavior.",
            "sentence": "Collaborate with product owners and architects on making design decisions.Development of end user application with high scalability and high throughput.Provide technical and design guidance and create standards.Improve, optimize and identify opportunities for improved software development processes.Expertise in designing enterprise applications",
            "similarity": 0.5316
          },
          {
            "kra_text": "Integrates frontend views with RESTful or GraphQL backend APIs, handling async data fetching, loading states, error boundaries, and cache invalidation.",
            "sentence": "AngularReactJSJava 8JavaScriptUnit TestingRest API",
            "similarity": 0.4703
          },
          {
            "kra_text": "Builds responsive user interfaces and interactive web components using React, Vue, or Angular with TypeScript, HTML5, and modern CSS for browser-based applications.",
            "sentence": "Working experience on Java 8 (Good to have 9/10/11)Springboot microservices, Spring (spring security, spring integration, spring batch, spring data, spring cloud, spring boot)JPA (Java Persistent API), Hibernate, MyBatisUnix/Linux-Any Unix flavorSQL/Database knowledge/Performance-TuningAny messaging knowledge [JMS, KAFKA]HTML5, CSS, JavaScript [ES6] and Other Front-End TechnologiesjQuery, Bootstrap, ReactJS, AngularJS, VueJSNode JS [Good to have]Responsive Design, Cross-Platform [Web and Mobile], Cross-Browser Environment compatibility, Object-Oriented Design, Web Services (REST/SOAP)Web Services (Restful/Any web services)-Consumption experience is fineExperience With Git, BitbucketKnowledgeable of REST-Based APIsKnowledgeable of Web Application Development FrameworksManage and Prioritize Project WorkKnowledge in MariaDB, or at least should have knowledge in RMDB (e.g, MySQL, Oracle)Preferable to have knowledge in Private Cloud platform (Openshift, Kubernetes, Docker)AWS [Good to Have]Hadoop: Hive/Impala/Spark [Good to Have]Any NoSQL Database [DynamoDB, MongoDB, CASSANDRA, HBase, etc\u2026][Good to Have]Familiar with Agile practiceEstablish Continuous integration and Release automationGood Communication and Troubleshooting skills",
            "similarity": 0.3966
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 7,
        "score": 0.4662,
        "slug": "frontend-engineer",
        "total_count": null
      },
      {
        "display_name": "Angular Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "Angular component development",
            "sentence": "AngularReactJSJava 8JavaScriptUnit TestingRest API",
            "similarity": 0.5281
          },
          {
            "kra_text": "collaboration with design and QA",
            "sentence": "Collaborate with product owners and architects on making design decisions.Development of end user application with high scalability and high throughput.Provide technical and design guidance and create standards.Improve, optimize and identify opportunities for improved software development processes.Expertise in designing enterprise applications",
            "similarity": 0.5218
          },
          {
            "kra_text": "UI responsiveness and performance",
            "sentence": "Working experience on Java 8 (Good to have 9/10/11)Springboot microservices, Spring (spring security, spring integration, spring batch, spring data, spring cloud, spring boot)JPA (Java Persistent API), Hibernate, MyBatisUnix/Linux-Any Unix flavorSQL/Database knowledge/Performance-TuningAny messaging knowledge [JMS, KAFKA]HTML5, CSS, JavaScript [ES6] and Other Front-End TechnologiesjQuery, Bootstrap, ReactJS, AngularJS, VueJSNode JS [Good to have]Responsive Design, Cross-Platform [Web and Mobile], Cross-Browser Environment compatibility, Object-Oriented Design, Web Services (REST/SOAP)Web Services (Restful/Any web services)-Consumption experience is fineExperience With Git, BitbucketKnowledgeable of REST-Based APIsKnowledgeable of Web Application Development FrameworksManage and Prioritize Project WorkKnowledge in MariaDB, or at least should have knowledge in RMDB (e.g, MySQL, Oracle)Preferable to have knowledge in Private Cloud platform (Openshift, Kubernetes, Docker)AWS [Good to Have]Hadoop: Hive/Impala/Spark [Good to Have]Any NoSQL Database [DynamoDB, MongoDB, CASSANDRA, HBase, etc\u2026][Good to Have]Familiar with Agile practiceEstablish Continuous integration and Release automationGood Communication and Troubleshooting skills",
            "similarity": 0.3329
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 90,
        "score": 0.4609,
        "slug": "angular-frontend-developer",
        "total_count": null
      },
      {
        "display_name": "Flutter Developer",
        "kra_matches": [
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Collaborate with product owners and architects on making design decisions.Development of end user application with high scalability and high throughput.Provide technical and design guidance and create standards.Improve, optimize and identify opportunities for improved software development processes.Expertise in designing enterprise applications",
            "similarity": 0.6115
          },
          {
            "kra_text": "collaborate with design, product, and backend teams",
            "sentence": "Working experience on Java 8 (Good to have 9/10/11)Springboot microservices, Spring (spring security, spring integration, spring batch, spring data, spring cloud, spring boot)JPA (Java Persistent API), Hibernate, MyBatisUnix/Linux-Any Unix flavorSQL/Database knowledge/Performance-TuningAny messaging knowledge [JMS, KAFKA]HTML5, CSS, JavaScript [ES6] and Other Front-End TechnologiesjQuery, Bootstrap, ReactJS, AngularJS, VueJSNode JS [Good to have]Responsive Design, Cross-Platform [Web and Mobile], Cross-Browser Environment compatibility, Object-Oriented Design, Web Services (REST/SOAP)Web Services (Restful/Any web services)-Consumption experience is fineExperience With Git, BitbucketKnowledgeable of REST-Based APIsKnowledgeable of Web Application Development FrameworksManage and Prioritize Project WorkKnowledge in MariaDB, or at least should have knowledge in RMDB (e.g, MySQL, Oracle)Preferable to have knowledge in Private Cloud platform (Openshift, Kubernetes, Docker)AWS [Good to Have]Hadoop: Hive/Impala/Spark [Good to Have]Any NoSQL Database [DynamoDB, MongoDB, CASSANDRA, HBase, etc\u2026][Good to Have]Familiar with Agile practiceEstablish Continuous integration and Release automationGood Communication and Troubleshooting skills",
            "similarity": 0.3768
          },
          {
            "kra_text": "structure reusable application code",
            "sentence": "AngularReactJSJava 8JavaScriptUnit TestingRest API",
            "similarity": 0.368
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 74,
        "score": 0.4521,
        "slug": "flutter-developer",
        "total_count": null
      },
      {
        "display_name": "DevOps Engineer",
        "kra_matches": [
          {
            "kra_text": "Collaborates with development teams to improve build processes, reduce deployment friction, containerize applications, and adopt DevOps best practices.",
            "sentence": "Collaborate with product owners and architects on making design decisions.Development of end user application with high scalability and high throughput.Provide technical and design guidance and create standards.Improve, optimize and identify opportunities for improved software development processes.Expertise in designing enterprise applications",
            "similarity": 0.5704
          },
          {
            "kra_text": "Collaborates with development teams to improve build processes, reduce deployment friction, containerize applications, and adopt DevOps best practices.",
            "sentence": "Working experience on Java 8 (Good to have 9/10/11)Springboot microservices, Spring (spring security, spring integration, spring batch, spring data, spring cloud, spring boot)JPA (Java Persistent API), Hibernate, MyBatisUnix/Linux-Any Unix flavorSQL/Database knowledge/Performance-TuningAny messaging knowledge [JMS, KAFKA]HTML5, CSS, JavaScript [ES6] and Other Front-End TechnologiesjQuery, Bootstrap, ReactJS, AngularJS, VueJSNode JS [Good to have]Responsive Design, Cross-Platform [Web and Mobile], Cross-Browser Environment compatibility, Object-Oriented Design, Web Services (REST/SOAP)Web Services (Restful/Any web services)-Consumption experience is fineExperience With Git, BitbucketKnowledgeable of REST-Based APIsKnowledgeable of Web Application Development FrameworksManage and Prioritize Project WorkKnowledge in MariaDB, or at least should have knowledge in RMDB (e.g, MySQL, Oracle)Preferable to have knowledge in Private Cloud platform (Openshift, Kubernetes, Docker)AWS [Good to Have]Hadoop: Hive/Impala/Spark [Good to Have]Any NoSQL Database [DynamoDB, MongoDB, CASSANDRA, HBase, etc\u2026][Good to Have]Familiar with Agile practiceEstablish Continuous integration and Release automationGood Communication and Troubleshooting skills",
            "similarity": 0.4317
          },
          {
            "kra_text": "Builds and maintains CI/CD pipelines using Jenkins, GitHub Actions, GitLab CI, or CircleCI to automate build, test, security scanning, and deployment workflows.",
            "sentence": "AngularReactJSJava 8JavaScriptUnit TestingRest API",
            "similarity": 0.3023
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 10,
        "score": 0.4348,
        "slug": "devops-engineer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "Fullstack Developer",
        "kra_matches": null,
        "matched_count": 13,
        "matched_skills": [
          "Angular",
          "Angular Router",
          "Bootstrap",
          "CSS",
          "Hibernate",
          "JPA",
          "Java",
          "JavaScript",
          "MySQL",
          "REST",
          "React",
          "Spring Boot",
          "Spring Data"
        ],
        "role_id": 15,
        "score": 0.3714,
        "slug": "full-stack-engineer",
        "total_count": 35
      },
      {
        "display_name": "Node.js Backend Developer",
        "kra_matches": null,
        "matched_count": 12,
        "matched_skills": [
          "ECMAScript",
          "Hibernate",
          "JPA",
          "JavaScript",
          "Kafka",
          "MySQL",
          "Oracle Database",
          "REST",
          "SOAP",
          "Spring Boot",
          "Spring Data",
          "Spring Security"
        ],
        "role_id": 82,
        "score": 0.3429,
        "slug": "node-backend-developer",
        "total_count": 35
      },
      {
        "display_name": "Backend Developer",
        "kra_matches": null,
        "matched_count": 12,
        "matched_skills": [
          "Hibernate",
          "JPA",
          "Java",
          "JavaScript",
          "Kafka",
          "MySQL",
          "Oracle Database",
          "REST",
          "SOAP",
          "Spring Boot",
          "Spring Data",
          "Spring Security"
        ],
        "role_id": 1,
        "score": 0.3429,
        "slug": "backend-engineer",
        "total_count": 35
      },
      {
        "display_name": "Kotlin Backend Developer",
        "kra_matches": null,
        "matched_count": 11,
        "matched_skills": [
          "Hibernate",
          "JPA",
          "Java",
          "Kafka",
          "MySQL",
          "Oracle Database",
          "REST",
          "SOAP",
          "Spring Boot",
          "Spring Data",
          "Spring Security"
        ],
        "role_id": 84,
        "score": 0.3143,
        "slug": "kotlin-server-backend-developer",
        "total_count": 35
      },
      {
        "display_name": "Python Backend Developer",
        "kra_matches": null,
        "matched_count": 10,
        "matched_skills": [
          "Hibernate",
          "JPA",
          "Kafka",
          "MySQL",
          "Oracle Database",
          "REST",
          "SOAP",
          "Spring Boot",
          "Spring Data",
          "Spring Security"
        ],
        "role_id": 80,
        "score": 0.2857,
        "slug": "python-backend-developer",
        "total_count": 35
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": true,
    "case": "A",
    "chosen_role": {
      "display_name": "Fullstack Developer",
      "kra_matches": null,
      "matched_count": null,
      "matched_skills": null,
      "role_id": 15,
      "score": 1.0,
      "slug": "full-stack-engineer",
      "total_count": null
    },
    "confidence": 0.95,
    "is_new_role": false,
    "llm2_fired": false,
    "llm2_reasoning": null,
    "matched_dimensions": [],
    "matched_kras": [],
    "matched_skills": [],
    "new_role_display_name": null,
    "new_role_slug": null,
    "queued": false,
    "reasoning": "Multi-alias tie (3 roles at 1.0) resolved by TIER_A_KRA: Fullstack Developer",
    "sub_role": null
  },
  "stage5_updates": 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": 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": 79,
      "existing_alias_text": "Spring Boot",
      "input_term": "Spring Boot",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Spring Boot",
        "id": 6,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "spring-boot",
        "sub_category_id": 35,
        "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": 3492,
      "existing_alias_text": "Spring Security",
      "input_term": "Spring Security",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Spring Security",
        "id": 2234,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "spring-security",
        "sub_category_id": 1677,
        "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": 5123,
      "existing_alias_text": "Spring Data",
      "input_term": "Spring Data",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Spring Data",
        "id": 3557,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "spring-data",
        "sub_category_id": 1670,
        "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": 3420,
      "existing_alias_text": "JPA",
      "input_term": "JPA",
      "matched_canonical": {
        "category_id": 12,
        "display_name": "JPA",
        "id": 2196,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "STANDARD",
        "slug": "jpa",
        "sub_category_id": 3566,
        "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": 149,
      "existing_alias_text": "Hibernate",
      "input_term": "Hibernate",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "Hibernate",
        "id": 21,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "hibernate",
        "sub_category_id": 39,
        "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"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 173,
      "existing_alias_text": "Kafka",
      "input_term": "Kafka",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "Kafka",
        "id": 36,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "kafka",
        "sub_category_id": 3533,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 4554,
      "existing_alias_text": "HTML5",
      "input_term": "HTML5",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "HTML5",
        "id": 3087,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "html5",
        "sub_category_id": 1467,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1107,
      "existing_alias_text": "CSS",
      "input_term": "CSS",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "CSS",
        "id": 623,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "css",
        "sub_category_id": 486,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 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": 1030,
      "existing_alias_text": "ES6",
      "input_term": "ES6",
      "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": 2986,
      "existing_alias_text": "jQuery",
      "input_term": "jQuery",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "jQuery",
        "id": 1968,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "jquery",
        "sub_category_id": 1470,
        "typical_lifespan": "EVERGREEN",
        "volatility": "DEPRECATED"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 2991,
      "existing_alias_text": "Bootstrap",
      "input_term": "Bootstrap",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Bootstrap",
        "id": 1970,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "bootstrap",
        "sub_category_id": 341,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1047,
      "existing_alias_text": "React",
      "input_term": "React",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "React",
        "id": 610,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react",
        "sub_category_id": 1072,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1076,
      "existing_alias_text": "AngularJS",
      "input_term": "AngularJS",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Angular",
        "id": 612,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "angular",
        "sub_category_id": 1072,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 4689,
      "existing_alias_text": "Vue.js",
      "input_term": "Vue.js",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Vue.js",
        "id": 3201,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "vue-js",
        "sub_category_id": 1072,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 2500,
      "existing_alias_text": "Node.js",
      "input_term": "Node.js",
      "matched_canonical": {
        "category_id": 67,
        "display_name": "Node.js",
        "id": 1564,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "RUNTIME",
        "slug": "node-js",
        "sub_category_id": 1872,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 106,
      "existing_alias_text": "REST",
      "input_term": "REST",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "REST",
        "id": 11,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "rest",
        "sub_category_id": 2122,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 211,
      "existing_alias_text": "SOAP",
      "input_term": "SOAP",
      "matched_canonical": {
        "category_id": 10,
        "display_name": "SOAP",
        "id": 70,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "soap",
        "sub_category_id": 2347,
        "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": 1613,
      "existing_alias_text": "Git",
      "input_term": "Git",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Git",
        "id": 1002,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "git",
        "sub_category_id": 730,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 134,
      "existing_alias_text": "MySQL",
      "input_term": "MySQL",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "MySQL",
        "id": 17,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mysql",
        "sub_category_id": 29,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 2512,
      "existing_alias_text": "Oracle Database",
      "input_term": "Oracle Database",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "Oracle Database",
        "id": 1566,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "oracle-database",
        "sub_category_id": 29,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1267,
      "existing_alias_text": "Kubernetes",
      "input_term": "Kubernetes",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "Kubernetes",
        "id": 726,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "kubernetes",
        "sub_category_id": 557,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 198,
      "existing_alias_text": "Docker",
      "input_term": "Docker",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Docker",
        "id": 61,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "docker",
        "sub_category_id": 63,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 406,
      "existing_alias_text": "AWS",
      "input_term": "AWS",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "AWS",
        "id": 187,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "aws",
        "sub_category_id": 46,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 4198,
      "existing_alias_text": "Hive",
      "input_term": "Hive",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "Hive",
        "id": 2754,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "hive",
        "sub_category_id": 2242,
        "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": 2510,
      "existing_alias_text": "spark",
      "input_term": "Spark",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Apache Spark",
        "id": 1350,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "apache-spark",
        "sub_category_id": 1021,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "TODO: REMOVE AFTER TESTING \u2014 alias DB write disabled",
      "alias_persisted": false,
      "existing_alias_id": null,
      "existing_alias_text": null,
      "input_term": "DynamoDB",
      "matched_canonical": {
        "category_id": 11,
        "display_name": "Amazon DynamoDB",
        "id": 93,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "amazon-dynamodb",
        "sub_category_id": 55,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "embedding_display_name"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 232,
      "existing_alias_text": "MongoDB",
      "input_term": "MongoDB",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "MongoDB",
        "id": 91,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mongodb",
        "sub_category_id": 27,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 2013,
      "existing_alias_text": "Cassandra",
      "input_term": "Cassandra",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "Cassandra",
        "id": 1354,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "cassandra",
        "sub_category_id": 31,
        "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": 2011,
      "existing_alias_text": "HBase",
      "input_term": "HBase",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "HBase",
        "id": 1352,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "hbase",
        "sub_category_id": 31,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 868,
      "existing_alias_text": "Agile",
      "input_term": "Agile",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "Agile",
        "id": 520,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "agile",
        "sub_category_id": 367,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 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"
    }
  ],
  "candidate_roles": [
    {
      "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"
    },
    {
      "display_name": "Android Developer",
      "id": 4,
      "rationale": null,
      "role_archetype": null,
      "slug": "android-engineer",
      "source": "db"
    },
    {
      "display_name": "Native Mobile Developer",
      "id": 75,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "native-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "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": 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": "Data Engineer",
      "id": 2,
      "rationale": null,
      "role_archetype": null,
      "slug": "data-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": ".NET Backend Developer",
      "id": 83,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "dotnet-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Go Backend Developer",
      "id": 81,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "go-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Ruby Backend Developer",
      "id": 85,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "ruby-backend-developer",
      "source": "db"
    },
    {
      "display_name": "WordPress Dev",
      "id": 227,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "wordpress-dev",
      "source": "db"
    },
    {
      "display_name": "Frontend Developer",
      "id": 7,
      "rationale": null,
      "role_archetype": null,
      "slug": "frontend-engineer",
      "source": "db"
    },
    {
      "display_name": "React Frontend Developer",
      "id": 89,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "react-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Svelte Frontend Developer",
      "id": 92,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "svelte-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Vue Frontend Developer",
      "id": 91,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "vue-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Web Developer",
      "id": 25,
      "rationale": null,
      "role_archetype": null,
      "slug": "web-developer",
      "source": "db"
    },
    {
      "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": "Angular Frontend Developer",
      "id": 90,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "angular-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Hybrid Mobile Developer",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "hybrid-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "Ionic Developer",
      "id": 434,
      "rationale": null,
      "role_archetype": null,
      "slug": "ionic-developer",
      "source": "db"
    },
    {
      "display_name": "React Native Developer",
      "id": 73,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "react-native-developer",
      "source": "db"
    },
    {
      "display_name": "Magento Dev",
      "id": 231,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "magento-dev",
      "source": "db"
    },
    {
      "display_name": "Cloud Architect",
      "id": 9,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-architect",
      "source": "db"
    },
    {
      "display_name": "DevOps Engineer",
      "id": 10,
      "rationale": null,
      "role_archetype": null,
      "slug": "devops-engineer",
      "source": "db"
    },
    {
      "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": "Cyber Security Engineer",
      "id": 5,
      "rationale": null,
      "role_archetype": null,
      "slug": "cybersecurity-engineer",
      "source": "db"
    },
    {
      "display_name": "AI Engineer",
      "id": 13,
      "rationale": null,
      "role_archetype": null,
      "slug": "ai-engineer",
      "source": "db"
    },
    {
      "display_name": "Cloud Security Engineer",
      "id": 23,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-security-engineer",
      "source": "db"
    },
    {
      "display_name": "Flutter Developer",
      "id": 74,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "flutter-developer",
      "source": "db"
    },
    {
      "display_name": "iOS Developer",
      "id": 6,
      "rationale": null,
      "role_archetype": null,
      "slug": "ios-engineer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Fullstack Developer",
    "id": 15,
    "rationale": "Multi-alias tie (3 roles at 1.0) resolved by TIER_A_KRA: Fullstack Developer",
    "role_archetype": null,
    "slug": "full-stack-engineer",
    "source": "db"
  },
  "dimensions": [
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Java Language and JVM",
        "id": 279,
        "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
        "slug": "java-language-and-jvm",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Kotlin and Java",
        "id": 161,
        "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
        "slug": "kotlin-and-java",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Languages",
        "id": 274,
        "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
        "slug": "native-mobile-languages",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Pega Programming Languages \u0026 DSLs",
        "id": 267,
        "rationale": "Programming languages and domain-specific languages used in Pega development.",
        "slug": "pega-programming-languages-dsls",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Pega Developer",
          "id": 24,
          "rationale": null,
          "role_archetype": null,
          "slug": "pega-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for Data Work",
        "id": 21,
        "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
        "slug": "programming-languages-for-data-work",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Web Application Frameworks",
        "id": 2,
        "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
        "slug": "web-application-frameworks",
        "source": "db"
      },
      "input_skill": "Spring Boot",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Web Service Frameworks",
        "id": 390,
        "rationale": "Server-side Kotlin frameworks and runtimes used to build HTTP services, middleware, controllers, and request pipelines. This cluster is the main entry point for backend endpoints and service behavior.",
        "slug": "web-service-frameworks",
        "source": "db"
      },
      "input_skill": "Spring Boot",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Authentication and Authorization",
        "id": 6,
        "rationale": "Identity, session, and access-control mechanisms used to protect PHP backend resources. This includes login flows, token handling, role checks, permissions, and policy enforcement in server-side code.",
        "slug": "authentication-and-authorization",
        "source": "db"
      },
      "input_skill": "Spring Security",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Backend Authentication and Authorization",
        "id": 386,
        "rationale": "Identity and access control mechanisms used by backend services to authenticate users or clients and enforce permissions on protected resources. This includes token and session handling, OAuth 2.0 / OpenID Connect / SAML flows, JWT and access tokens, API keys, MFA, role- or claim-based authorization, RBAC/ABAC, scopes, policies, Spring Security, and authorization filters.",
        "slug": "backend-authentication-and-authorization",
        "source": "db"
      },
      "input_skill": "Spring Security",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "ORMs and Data Access Layers",
        "id": 5,
        "rationale": "Libraries and patterns used to map application objects to persistent storage and encapsulate database access. This cluster covers repository patterns, query builders, and persistence abstractions.",
        "slug": "orms-and-data-access-layers",
        "source": "db"
      },
      "input_skill": "Spring Data",
      "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": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Application ORM and Repository-Based Data Access",
        "id": 459,
        "rationale": "Libraries, patterns, and abstractions used in application service code to map objects/entities to relational databases and encapsulate persistence access. This includes ORM frameworks, repository/DAO patterns, entity/object mapping, query composition/execution, transactions, and connection handling across Scala and Java ecosystems (for example Slick, Doobie, Quill, Hibernate, JPA, Spring Data JPA, JPQL, and Criteria-style query APIs).",
        "slug": "application-orm-and-repository-based-data-access",
        "source": "db"
      },
      "input_skill": "JPA",
      "llm_role": null,
      "roles_from_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": "ORMs and Data Access Layers",
        "id": 5,
        "rationale": "Libraries and patterns used to map application objects to persistent storage and encapsulate database access. This cluster covers repository patterns, query builders, and persistence abstractions.",
        "slug": "orms-and-data-access-layers",
        "source": "db"
      },
      "input_skill": "JPA",
      "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": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Application ORM and Repository-Based Data Access",
        "id": 459,
        "rationale": "Libraries, patterns, and abstractions used in application service code to map objects/entities to relational databases and encapsulate persistence access. This includes ORM frameworks, repository/DAO patterns, entity/object mapping, query composition/execution, transactions, and connection handling across Scala and Java ecosystems (for example Slick, Doobie, Quill, Hibernate, JPA, Spring Data JPA, JPQL, and Criteria-style query APIs).",
        "slug": "application-orm-and-repository-based-data-access",
        "source": "db"
      },
      "input_skill": "Hibernate",
      "llm_role": null,
      "roles_from_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": "ORMs and Data Access Layers",
        "id": 5,
        "rationale": "Libraries and patterns used to map application objects to persistent storage and encapsulate database access. This cluster covers repository patterns, query builders, and persistence abstractions.",
        "slug": "orms-and-data-access-layers",
        "source": "db"
      },
      "input_skill": "Hibernate",
      "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": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "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 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"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Asynchronous Messaging and Event Streaming",
        "id": 297,
        "rationale": "Asynchronous communication patterns and broker technologies used to decouple backend services and move work off the request path. Includes queues, pub/sub, event streams, consumer groups, dead-letter queues, and delivery semantics across systems such as Kafka, RabbitMQ, NATS, SQS/SNS, Pulsar, and ActiveMQ.",
        "slug": "asynchronous-messaging-and-event-streaming",
        "source": "db"
      },
      "input_skill": "Kafka",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Messaging and Background Jobs",
        "id": 291,
        "rationale": "Asynchronous processing patterns and worker systems used to decouple backend work from request handling. This is a coherent cluster because the role supports background jobs, retries, and deferred processing.",
        "slug": "messaging-and-background-jobs",
        "source": "db"
      },
      "input_skill": "Kafka",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Messaging and Event Streaming",
        "id": 8,
        "rationale": "Transport-layer systems used to move events and decouple producers from consumers. Data engineers use these systems to ingest, buffer, and distribute event data before downstream processing.",
        "slug": "messaging-and-event-streaming",
        "source": "db"
      },
      "input_skill": "Kafka",
      "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": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Web Standards \u0026 Compliance",
        "id": 343,
        "rationale": "Ensuring WordPress sites adhere to web markup, styling, accessibility, and privacy regulations.",
        "slug": "web-standards-compliance",
        "source": "db"
      },
      "input_skill": "HTML5",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "WordPress Dev",
          "id": 227,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "wordpress-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CSS Architecture and Styling",
        "id": 117,
        "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
        "slug": "css-architecture-and-styling",
        "source": "db"
      },
      "input_skill": "CSS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 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": "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": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages \u0026 Template Languages",
        "id": 359,
        "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
        "slug": "programming-languages-template-languages",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Drupal Dev",
          "id": 228,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "drupal-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Sitecore Development Languages",
        "id": 438,
        "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
        "slug": "sitecore-development-languages",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Storefront JavaScript and DOM Behavior",
        "id": 422,
        "rationale": "Client-side behavior used to enhance Shopify storefront interactions beyond static theme rendering. This includes interactive UI logic, event handling, and progressive enhancement within theme constraints.",
        "slug": "storefront-javascript-and-dom-behavior",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Shopify Dev",
          "id": 230,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "shopify-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "ES6",
      "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": "ES6",
      "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": "ES6",
      "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": "ES6",
      "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": "ES6",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages \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": "ES6",
      "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": "ES6",
      "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": "ES6",
      "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": "Application Frameworks \u0026 Libraries",
        "id": 451,
        "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
        "slug": "application-frameworks-libraries",
        "source": "db"
      },
      "input_skill": "jQuery",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frameworks \u0026 Libraries",
        "id": 360,
        "rationale": "The PHP frameworks and JavaScript libraries commonly employed within Drupal projects for building features and integrations.",
        "slug": "frameworks-libraries",
        "source": "db"
      },
      "input_skill": "jQuery",
      "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": "JavaScript Checkout Behavior",
        "id": 393,
        "rationale": "Client-side behavior used to customize Magento storefront interactions, especially checkout and account flows. This includes Magento\u0027s browser-side component model and form behavior where commerce logic is implemented in the UI.",
        "slug": "javascript-checkout-behavior",
        "source": "db"
      },
      "input_skill": "jQuery",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Magento Dev",
          "id": 231,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "magento-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "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": "jQuery",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Shopify Dev",
          "id": 230,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "shopify-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Web UI \u0026 Integration Frameworks",
        "id": 268,
        "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
        "slug": "web-ui-integration-frameworks",
        "source": "db"
      },
      "input_skill": "jQuery",
      "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": "Component Libraries and Design Systems",
        "id": 118,
        "rationale": "Reusable UI kits and design-system implementations that standardize look, feel, and interaction patterns across products. This is a distinct cluster because frontend engineers frequently consume and extend these libraries.",
        "slug": "component-libraries-and-design-systems",
        "source": "db"
      },
      "input_skill": "Bootstrap",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Web UI \u0026 Integration Frameworks",
        "id": 268,
        "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
        "slug": "web-ui-integration-frameworks",
        "source": "db"
      },
      "input_skill": "Bootstrap",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Pega Developer",
          "id": 24,
          "rationale": null,
          "role_archetype": null,
          "slug": "pega-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Application Frameworks \u0026 Libraries",
        "id": 451,
        "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
        "slug": "application-frameworks-libraries",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frontend Frameworks and Libraries",
        "id": 434,
        "rationale": "Utilizing modern JavaScript frameworks and Shopify libraries to build dynamic and interactive storefronts.",
        "slug": "frontend-frameworks-and-libraries",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Shopify Dev",
          "id": 230,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "shopify-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "JavaScript for WordPress",
        "id": 329,
        "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
        "slug": "javascript-for-wordpress",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "WordPress Dev",
          "id": 227,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "wordpress-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Component Architecture",
        "id": 302,
        "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
        "slug": "react-component-architecture",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "UI Frameworks and Rendering",
        "id": 115,
        "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
        "slug": "ui-frameworks-and-rendering",
        "source": "db"
      },
      "input_skill": "React",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Angular Component Model and Templates",
        "id": 303,
        "rationale": "Core Angular framework surface for building reusable UI, composing views, and wiring component behavior. This is the main application substrate for browser features in this role.",
        "slug": "angular-component-model-and-templates",
        "source": "db"
      },
      "input_skill": "AngularJS",
      "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": "Application Frameworks \u0026 Libraries",
        "id": 451,
        "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
        "slug": "application-frameworks-libraries",
        "source": "db"
      },
      "input_skill": "AngularJS",
      "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": "UI Frameworks and Rendering",
        "id": 115,
        "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
        "slug": "ui-frameworks-and-rendering",
        "source": "db"
      },
      "input_skill": "AngularJS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frameworks \u0026 Libraries",
        "id": 360,
        "rationale": "The PHP frameworks and JavaScript libraries commonly employed within Drupal projects for building features and integrations.",
        "slug": "frameworks-libraries",
        "source": "db"
      },
      "input_skill": "Vue.js",
      "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": "JavaScript and TypeScript",
        "id": 114,
        "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
        "slug": "javascript-and-typescript",
        "source": "db"
      },
      "input_skill": "Node.js",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Web Application Frameworks",
        "id": 2,
        "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
        "slug": "web-application-frameworks",
        "source": "db"
      },
      "input_skill": "Node.js",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Design and Contracts",
        "id": 3,
        "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
        "slug": "api-design-and-contracts",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "API Interface and Contract Design",
        "id": 289,
        "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
        "slug": "api-interface-and-contract-design",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Integration Protocols \u0026 Standards",
        "id": 271,
        "rationale": "Standards and protocols for integrating Pega applications.",
        "slug": "integration-protocols-standards",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Pega Developer",
          "id": 24,
          "rationale": null,
          "role_archetype": null,
          "slug": "pega-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Standards \u0026 Protocols Compliance",
        "id": 452,
        "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
        "slug": "standards-protocols-compliance",
        "source": "db"
      },
      "input_skill": "REST",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "External System Integrations",
        "id": 14,
        "rationale": "Connecting backend services to third-party APIs and internal enterprise systems. This includes client libraries, webhooks, retries, data mapping, and integration failure handling.",
        "slug": "external-system-integrations",
        "source": "db"
      },
      "input_skill": "SOAP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Drupal Dev",
          "id": 228,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "drupal-dev",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Integration Protocols \u0026 Standards",
        "id": 271,
        "rationale": "Standards and protocols for integrating Pega applications.",
        "slug": "integration-protocols-standards",
        "source": "db"
      },
      "input_skill": "SOAP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Pega Developer",
          "id": 24,
          "rationale": null,
          "role_archetype": null,
          "slug": "pega-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Standards \u0026 Protocols Compliance",
        "id": 452,
        "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
        "slug": "standards-protocols-compliance",
        "source": "db"
      },
      "input_skill": "SOAP",
      "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": "Git",
      "llm_role": null,
      "roles_from_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": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Oracle Database",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Relational Database Design",
        "id": 4,
        "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
        "slug": "relational-database-design",
        "source": "db"
      },
      "input_skill": "Oracle Database",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Container Orchestration Platforms",
        "id": 134,
        "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
        "slug": "container-orchestration-platforms",
        "source": "db"
      },
      "input_skill": "Kubernetes",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Kubernetes for ML Workloads",
        "id": 47,
        "rationale": "Kubernetes-native components used to schedule, accelerate, and isolate ML training and serving workloads. This includes GPU enablement and ML-specific controllers rather than generic cluster administration.",
        "slug": "kubernetes-for-ml-workloads",
        "source": "db"
      },
      "input_skill": "Kubernetes",
      "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": "Containerization and Image Builds",
        "id": 152,
        "rationale": "Container image creation, tagging, hardening, and registry workflows used to package services for deployment. This is coherent because DevOps often owns the build-to-image path that feeds runtime environments.",
        "slug": "containerization-and-image-builds",
        "source": "db"
      },
      "input_skill": "Docker",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Cloud Platforms",
        "id": 418,
        "rationale": "Platform-as-a-Service and container environments for deploying Ruby applications.",
        "slug": "deployment-and-cloud-platforms",
        "source": "db"
      },
      "input_skill": "Docker",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Runtime Configuration",
        "id": 13,
        "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
        "slug": "deployment-and-runtime-configuration",
        "source": "db"
      },
      "input_skill": "Docker",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        },
        {
          "display_name": "Data Engineer",
          "id": 2,
          "rationale": null,
          "role_archetype": null,
          "slug": "data-engineer",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Go Backend Developer",
          "id": 81,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "go-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "MLOps Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms for AI Deployment",
        "id": 211,
        "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
        "slug": "cloud-platforms-for-ai-deployment",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Provider Platforms",
        "id": 131,
        "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
        "slug": "cloud-provider-platforms",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Posture Tools",
        "id": 64,
        "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
        "slug": "cloud-security-posture-tools",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        },
        {
          "display_name": "Cyber Security Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Local Persistence and Offline Behavior",
        "id": 85,
        "rationale": "On-device storage used for caching, offline support, and durable client state. This cluster is coherent because iOS apps often need to preserve user progress and data when connectivity is limited.",
        "slug": "local-persistence-and-offline-behavior",
        "source": "db"
      },
      "input_skill": "Hive",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Flutter Developer",
          "id": 74,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "flutter-developer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        },
        {
          "display_name": "iOS Developer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "ETL and ELT Tooling",
        "id": 24,
        "rationale": "Packaged tools for extracting, loading, and transforming data across systems. This dimension covers connector-based ingestion, transformation frameworks, and managed integration products.",
        "slug": "etl-and-elt-tooling",
        "source": "db"
      },
      "input_skill": "Spark",
      "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": "NoSQL Databases",
        "id": 19,
        "rationale": "Models and manages data using non-relational database systems.",
        "slug": "nosql-databases",
        "source": "db"
      },
      "input_skill": "DynamoDB",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "NoSQL Databases",
        "id": 19,
        "rationale": "Models and manages data using non-relational database systems.",
        "slug": "nosql-databases",
        "source": "db"
      },
      "input_skill": "MongoDB",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Storage and Data Services",
        "id": 144,
        "rationale": "Cloud-native storage and managed data services used to place workloads, choose durability tiers, and define platform boundaries. This is a coherent cluster because architects evaluate storage fit, access patterns, and managed service tradeoffs.",
        "slug": "cloud-storage-and-data-services",
        "source": "db"
      },
      "input_skill": "Cassandra",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Storage and Data Services",
        "id": 144,
        "rationale": "Cloud-native storage and managed data services used to place workloads, choose durability tiers, and define platform boundaries. This is a coherent cluster because architects evaluate storage fit, access patterns, and managed service tradeoffs.",
        "slug": "cloud-storage-and-data-services",
        "source": "db"
      },
      "input_skill": "HBase",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Agile",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Unit Testing",
      "llm_role": null,
      "roles_from_db": []
    }
  ],
  "input_final_skills": [
    "Java",
    "Spring Boot",
    "Spring Security",
    "Spring Integration",
    "Spring Batch",
    "Spring Data",
    "Spring Cloud",
    "JPA",
    "Hibernate",
    "MyBatis",
    "Linux",
    "Unix",
    "SQL",
    "JMS",
    "Kafka",
    "HTML5",
    "CSS",
    "JavaScript",
    "ES6",
    "jQuery",
    "Bootstrap",
    "React",
    "AngularJS",
    "Vue.js",
    "Node.js",
    "REST",
    "SOAP",
    "Git",
    "Bitbucket",
    "MariaDB",
    "MySQL",
    "Oracle Database",
    "OpenShift",
    "Kubernetes",
    "Docker",
    "AWS",
    "Hive",
    "Impala",
    "Spark",
    "DynamoDB",
    "MongoDB",
    "Cassandra",
    "HBase",
    "Agile",
    "Continuous Integration",
    "Release Automation",
    "Unit Testing"
  ],
  "input_llm_skills": [
    "Java",
    "Spring Boot",
    "Spring Security",
    "Spring Integration",
    "Spring Batch",
    "Spring Data",
    "Spring Cloud",
    "JPA",
    "Hibernate",
    "MyBatis",
    "Linux",
    "Unix",
    "SQL",
    "JMS",
    "Kafka",
    "HTML5",
    "CSS",
    "JavaScript",
    "ES6",
    "jQuery",
    "Bootstrap",
    "React",
    "AngularJS",
    "Vue.js",
    "Node.js",
    "REST",
    "SOAP",
    "Git",
    "Bitbucket",
    "MariaDB",
    "MySQL",
    "Oracle Database",
    "OpenShift",
    "Kubernetes",
    "Docker",
    "AWS",
    "Hive",
    "Impala",
    "Spark",
    "DynamoDB",
    "MongoDB",
    "Cassandra",
    "HBase",
    "Agile",
    "Continuous Integration",
    "Release Automation",
    "Unit Testing"
  ],
  "new_aliases_persisted": 0,
  "run_id": "2f41f803-2392-4fba-bac3-8ea9ed2a2eb1",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "Java",
          "alias_type": "CANONICAL",
          "id": 1,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK",
          "alias_type": "VERSION",
          "id": 2968,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 10",
          "alias_type": "VERSION",
          "id": 2194,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 11",
          "alias_type": "VERSION",
          "id": 4,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 12",
          "alias_type": "VERSION",
          "id": 2196,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 13",
          "alias_type": "VERSION",
          "id": 2197,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 14",
          "alias_type": "VERSION",
          "id": 2198,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 15",
          "alias_type": "VERSION",
          "id": 2199,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 16",
          "alias_type": "VERSION",
          "id": 2200,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 17",
          "alias_type": "VERSION",
          "id": 5,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 18",
          "alias_type": "VERSION",
          "id": 2202,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 19",
          "alias_type": "VERSION",
          "id": 2203,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 20",
          "alias_type": "VERSION",
          "id": 2204,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 21",
          "alias_type": "VERSION",
          "id": 6,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 5",
          "alias_type": "VERSION",
          "id": 2189,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 6",
          "alias_type": "VERSION",
          "id": 2190,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 7",
          "alias_type": "VERSION",
          "id": 2191,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 8",
          "alias_type": "VERSION",
          "id": 3,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 9",
          "alias_type": "VERSION",
          "id": 2193,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.0",
          "alias_type": "VERSION",
          "id": 11,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.1",
          "alias_type": "VERSION",
          "id": 12,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.2",
          "alias_type": "VERSION",
          "id": 13,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.3",
          "alias_type": "VERSION",
          "id": 14,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.4",
          "alias_type": "VERSION",
          "id": 15,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.5",
          "alias_type": "VERSION",
          "id": 16,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.6",
          "alias_type": "VERSION",
          "id": 17,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.7",
          "alias_type": "VERSION",
          "id": 18,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 1.8",
          "alias_type": "VERSION",
          "id": 19,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 10",
          "alias_type": "VERSION",
          "id": 2211,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 11",
          "alias_type": "VERSION",
          "id": 8,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 12",
          "alias_type": "VERSION",
          "id": 2213,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 13",
          "alias_type": "VERSION",
          "id": 2214,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 14",
          "alias_type": "VERSION",
          "id": 2215,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 15",
          "alias_type": "VERSION",
          "id": 2216,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 16",
          "alias_type": "VERSION",
          "id": 2217,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 17",
          "alias_type": "VERSION",
          "id": 9,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 18",
          "alias_type": "VERSION",
          "id": 2219,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 19",
          "alias_type": "VERSION",
          "id": 2220,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 20",
          "alias_type": "VERSION",
          "id": 2221,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 21",
          "alias_type": "VERSION",
          "id": 10,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 5",
          "alias_type": "VERSION",
          "id": 288,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 6",
          "alias_type": "VERSION",
          "id": 289,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 7",
          "alias_type": "VERSION",
          "id": 290,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 8",
          "alias_type": "VERSION",
          "id": 7,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java 9",
          "alias_type": "VERSION",
          "id": 2210,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java11",
          "alias_type": "VERSION",
          "id": 2976,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java17",
          "alias_type": "VERSION",
          "id": 2977,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java21",
          "alias_type": "VERSION",
          "id": 2978,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Java8",
          "alias_type": "VERSION",
          "id": 2971,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 11",
          "alias_type": "VERSION",
          "id": 21,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 17",
          "alias_type": "VERSION",
          "id": 22,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 21",
          "alias_type": "VERSION",
          "id": 23,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "OpenJDK 8",
          "alias_type": "VERSION",
          "id": 20,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 11",
          "alias_type": "VERSION",
          "id": 1512,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 17",
          "alias_type": "VERSION",
          "id": 1513,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 21",
          "alias_type": "VERSION",
          "id": 1514,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 4",
          "alias_type": "VERSION",
          "id": 1496,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 5",
          "alias_type": "VERSION",
          "id": 1497,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 6",
          "alias_type": "VERSION",
          "id": 1498,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 7",
          "alias_type": "VERSION",
          "id": 1499,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java 8",
          "alias_type": "VERSION",
          "id": 1500,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java lts",
          "alias_type": "VERSION",
          "id": 3122,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-11",
          "alias_type": "VERSION",
          "id": 1515,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-17",
          "alias_type": "VERSION",
          "id": 1516,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-21",
          "alias_type": "VERSION",
          "id": 1517,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-4",
          "alias_type": "VERSION",
          "id": 1501,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-5",
          "alias_type": "VERSION",
          "id": 1502,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-6",
          "alias_type": "VERSION",
          "id": 1503,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-7",
          "alias_type": "VERSION",
          "id": 1504,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java-8",
          "alias_type": "VERSION",
          "id": 1505,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java11",
          "alias_type": "VERSION",
          "id": 1506,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java17",
          "alias_type": "VERSION",
          "id": 1507,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java21",
          "alias_type": "VERSION",
          "id": 1508,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java4",
          "alias_type": "VERSION",
          "id": 1482,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java5",
          "alias_type": "VERSION",
          "id": 1483,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java6",
          "alias_type": "VERSION",
          "id": 1484,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java7",
          "alias_type": "VERSION",
          "id": 1485,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "java8",
          "alias_type": "VERSION",
          "id": 1486,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 11",
          "alias_type": "VERSION",
          "id": 1509,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 17",
          "alias_type": "VERSION",
          "id": 1510,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 21",
          "alias_type": "VERSION",
          "id": 1511,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 4",
          "alias_type": "VERSION",
          "id": 1487,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 5",
          "alias_type": "VERSION",
          "id": 1488,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 6",
          "alias_type": "VERSION",
          "id": 1489,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 7",
          "alias_type": "VERSION",
          "id": 1490,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk 8",
          "alias_type": "VERSION",
          "id": 1491,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk11",
          "alias_type": "VERSION",
          "id": 1492,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk17",
          "alias_type": "VERSION",
          "id": 1493,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk21",
          "alias_type": "VERSION",
          "id": 1494,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk4",
          "alias_type": "VERSION",
          "id": 1477,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk5",
          "alias_type": "VERSION",
          "id": 1478,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk6",
          "alias_type": "VERSION",
          "id": 1479,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk7",
          "alias_type": "VERSION",
          "id": 1480,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jdk8",
          "alias_type": "VERSION",
          "id": 1481,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "jvm21",
          "alias_type": "VERSION",
          "id": 1495,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Java",
        "id": 1,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "java",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Java Language and JVM",
            "id": 279,
            "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
            "slug": "java-language-and-jvm",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Kotlin and Java",
            "id": 161,
            "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
            "slug": "kotlin-and-java",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Languages",
            "id": 274,
            "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
            "slug": "native-mobile-languages",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Pega Programming Languages \u0026 DSLs",
            "id": 267,
            "rationale": "Programming languages and domain-specific languages used in Pega development.",
            "slug": "pega-programming-languages-dsls",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for Data Work",
            "id": 21,
            "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
            "slug": "programming-languages-for-data-work",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Java",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Spring Boot",
          "alias_type": "CANONICAL",
          "id": 79,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SB2",
          "alias_type": "VERSION",
          "id": 2278,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SB3",
          "alias_type": "VERSION",
          "id": 2279,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Boot 2",
          "alias_type": "VERSION",
          "id": 2280,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Boot 2.x",
          "alias_type": "VERSION",
          "id": 2282,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Boot 3",
          "alias_type": "VERSION",
          "id": 2281,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Boot 3.x",
          "alias_type": "VERSION",
          "id": 2283,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "boot2",
          "alias_type": "VERSION",
          "id": 3394,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "boot3",
          "alias_type": "VERSION",
          "id": 3395,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Spring Boot",
        "id": 6,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "spring-boot",
        "sub_category_id": 35,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web Application Frameworks",
            "id": 2,
            "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
            "slug": "web-application-frameworks",
            "source": "db"
          },
          "input_skill": "Spring Boot",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web Service Frameworks",
            "id": 390,
            "rationale": "Server-side Kotlin frameworks and runtimes used to build HTTP services, middleware, controllers, and request pipelines. This cluster is the main entry point for backend endpoints and service behavior.",
            "slug": "web-service-frameworks",
            "source": "db"
          },
          "input_skill": "Spring Boot",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Spring Boot",
      "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": "Spring Security",
          "alias_type": "CANONICAL",
          "id": 3492,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Security 4",
          "alias_type": "VERSION",
          "id": 5131,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Security 4.x",
          "alias_type": "VERSION",
          "id": 5134,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Security 5",
          "alias_type": "VERSION",
          "id": 3493,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Security 5.x",
          "alias_type": "VERSION",
          "id": 3497,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Security 6",
          "alias_type": "VERSION",
          "id": 3494,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Spring Security 6.x",
          "alias_type": "VERSION",
          "id": 3498,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "spring-security 5",
          "alias_type": "VERSION",
          "id": 3495,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "spring-security 6",
          "alias_type": "VERSION",
          "id": 3496,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Spring Security",
        "id": 2234,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "spring-security",
        "sub_category_id": 1677,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Authentication and Authorization",
            "id": 6,
            "rationale": "Identity, session, and access-control mechanisms used to protect PHP backend resources. This includes login flows, token handling, role checks, permissions, and policy enforcement in server-side code.",
            "slug": "authentication-and-authorization",
            "source": "db"
          },
          "input_skill": "Spring Security",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Backend Authentication and Authorization",
            "id": 386,
            "rationale": "Identity and access control mechanisms used by backend services to authenticate users or clients and enforce permissions on protected resources. This includes token and session handling, OAuth 2.0 / OpenID Connect / SAML flows, JWT and access tokens, API keys, MFA, role- or claim-based authorization, RBAC/ABAC, scopes, policies, Spring Security, and authorization filters.",
            "slug": "backend-authentication-and-authorization",
            "source": "db"
          },
          "input_skill": "Spring Security",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Spring Security",
      "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": "Spring Integration",
      "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": "spring-integration",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Spring Batch",
      "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": "spring-batch",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Spring Data",
          "alias_type": "CANONICAL",
          "id": 5123,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Spring Data",
        "id": 3557,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "spring-data",
        "sub_category_id": 1670,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "ORMs and Data Access Layers",
            "id": 5,
            "rationale": "Libraries and patterns used to map application objects to persistent storage and encapsulate database access. This cluster covers repository patterns, query builders, and persistence abstractions.",
            "slug": "orms-and-data-access-layers",
            "source": "db"
          },
          "input_skill": "Spring Data",
          "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": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Spring Data",
      "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": "Spring Cloud",
      "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": "spring-cloud",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "JPA",
          "alias_type": "CANONICAL",
          "id": 3420,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 12,
        "display_name": "JPA",
        "id": 2196,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "STANDARD",
        "slug": "jpa",
        "sub_category_id": 3566,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Application ORM and Repository-Based Data Access",
            "id": 459,
            "rationale": "Libraries, patterns, and abstractions used in application service code to map objects/entities to relational databases and encapsulate persistence access. This includes ORM frameworks, repository/DAO patterns, entity/object mapping, query composition/execution, transactions, and connection handling across Scala and Java ecosystems (for example Slick, Doobie, Quill, Hibernate, JPA, Spring Data JPA, JPQL, and Criteria-style query APIs).",
            "slug": "application-orm-and-repository-based-data-access",
            "source": "db"
          },
          "input_skill": "JPA",
          "llm_role": null,
          "roles_from_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": "ORMs and Data Access Layers",
            "id": 5,
            "rationale": "Libraries and patterns used to map application objects to persistent storage and encapsulate database access. This cluster covers repository patterns, query builders, and persistence abstractions.",
            "slug": "orms-and-data-access-layers",
            "source": "db"
          },
          "input_skill": "JPA",
          "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": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "JPA",
      "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": "Hibernate",
          "alias_type": "CANONICAL",
          "id": 149,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "Hibernate",
        "id": 21,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "hibernate",
        "sub_category_id": 39,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Application ORM and Repository-Based Data Access",
            "id": 459,
            "rationale": "Libraries, patterns, and abstractions used in application service code to map objects/entities to relational databases and encapsulate persistence access. This includes ORM frameworks, repository/DAO patterns, entity/object mapping, query composition/execution, transactions, and connection handling across Scala and Java ecosystems (for example Slick, Doobie, Quill, Hibernate, JPA, Spring Data JPA, JPQL, and Criteria-style query APIs).",
            "slug": "application-orm-and-repository-based-data-access",
            "source": "db"
          },
          "input_skill": "Hibernate",
          "llm_role": null,
          "roles_from_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": "ORMs and Data Access Layers",
            "id": 5,
            "rationale": "Libraries and patterns used to map application objects to persistent storage and encapsulate database access. This cluster covers repository patterns, query builders, and persistence abstractions.",
            "slug": "orms-and-data-access-layers",
            "source": "db"
          },
          "input_skill": "Hibernate",
          "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": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Hibernate",
      "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": "MyBatis",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Data Engineering Tools",
          "skill_nature": "TOOL",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "mybatis",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Linux",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Operating Systems",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "linux",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Unix",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Operating Systems",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "UNVERSIONED",
          "volatility": "STABLE"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "unix",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "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 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
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "JMS",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Messaging Systems",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "jms",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Kafka",
          "alias_type": "CANONICAL",
          "id": 173,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "Kafka",
        "id": 36,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "kafka",
        "sub_category_id": 3533,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Asynchronous Messaging and Event Streaming",
            "id": 297,
            "rationale": "Asynchronous communication patterns and broker technologies used to decouple backend services and move work off the request path. Includes queues, pub/sub, event streams, consumer groups, dead-letter queues, and delivery semantics across systems such as Kafka, RabbitMQ, NATS, SQS/SNS, Pulsar, and ActiveMQ.",
            "slug": "asynchronous-messaging-and-event-streaming",
            "source": "db"
          },
          "input_skill": "Kafka",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Messaging and Background Jobs",
            "id": 291,
            "rationale": "Asynchronous processing patterns and worker systems used to decouple backend work from request handling. This is a coherent cluster because the role supports background jobs, retries, and deferred processing.",
            "slug": "messaging-and-background-jobs",
            "source": "db"
          },
          "input_skill": "Kafka",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Messaging and Event Streaming",
            "id": 8,
            "rationale": "Transport-layer systems used to move events and decouple producers from consumers. Data engineers use these systems to ingest, buffer, and distribute event data before downstream processing.",
            "slug": "messaging-and-event-streaming",
            "source": "db"
          },
          "input_skill": "Kafka",
          "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": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Kafka",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "HTML5",
          "alias_type": "CANONICAL",
          "id": 4554,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "HTML5",
        "id": 3087,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "html5",
        "sub_category_id": 1467,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web Standards \u0026 Compliance",
            "id": 343,
            "rationale": "Ensuring WordPress sites adhere to web markup, styling, accessibility, and privacy regulations.",
            "slug": "web-standards-compliance",
            "source": "db"
          },
          "input_skill": "HTML5",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "WordPress Dev",
              "id": 227,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "wordpress-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "HTML5",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "CSS",
          "alias_type": "CANONICAL",
          "id": 1107,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "CSS",
        "id": 623,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "css",
        "sub_category_id": 486,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CSS Architecture and Styling",
            "id": 117,
            "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
            "slug": "css-architecture-and-styling",
            "source": "db"
          },
          "input_skill": "CSS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 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": "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": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages \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": "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": "ES6",
          "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": "ES6",
          "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": "ES6",
          "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": "ES6",
          "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": "ES6",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages \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": "ES6",
          "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": "ES6",
          "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": "ES6",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "ES6",
      "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": "jQuery",
          "alias_type": "CANONICAL",
          "id": 2986,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "jQuery",
        "id": 1968,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "jquery",
        "sub_category_id": 1470,
        "typical_lifespan": "EVERGREEN",
        "volatility": "DEPRECATED"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Application Frameworks \u0026 Libraries",
            "id": 451,
            "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
            "slug": "application-frameworks-libraries",
            "source": "db"
          },
          "input_skill": "jQuery",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frameworks \u0026 Libraries",
            "id": 360,
            "rationale": "The PHP frameworks and JavaScript libraries commonly employed within Drupal projects for building features and integrations.",
            "slug": "frameworks-libraries",
            "source": "db"
          },
          "input_skill": "jQuery",
          "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": "JavaScript Checkout Behavior",
            "id": 393,
            "rationale": "Client-side behavior used to customize Magento storefront interactions, especially checkout and account flows. This includes Magento\u0027s browser-side component model and form behavior where commerce logic is implemented in the UI.",
            "slug": "javascript-checkout-behavior",
            "source": "db"
          },
          "input_skill": "jQuery",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Magento Dev",
              "id": 231,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "magento-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "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": "jQuery",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web UI \u0026 Integration Frameworks",
            "id": 268,
            "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
            "slug": "web-ui-integration-frameworks",
            "source": "db"
          },
          "input_skill": "jQuery",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "jQuery",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Bootstrap",
          "alias_type": "CANONICAL",
          "id": 2991,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap 4",
          "alias_type": "VERSION",
          "id": 2996,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap 5",
          "alias_type": "VERSION",
          "id": 2997,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap 5.x",
          "alias_type": "VERSION",
          "id": 3240,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap v4",
          "alias_type": "VERSION",
          "id": 2998,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap v5",
          "alias_type": "VERSION",
          "id": 2999,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap4",
          "alias_type": "VERSION",
          "id": 2994,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bootstrap5",
          "alias_type": "VERSION",
          "id": 2995,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bs4",
          "alias_type": "VERSION",
          "id": 2992,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "bs5",
          "alias_type": "VERSION",
          "id": 2993,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Bootstrap",
        "id": 1970,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "bootstrap",
        "sub_category_id": 341,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Component Libraries and Design Systems",
            "id": 118,
            "rationale": "Reusable UI kits and design-system implementations that standardize look, feel, and interaction patterns across products. This is a distinct cluster because frontend engineers frequently consume and extend these libraries.",
            "slug": "component-libraries-and-design-systems",
            "source": "db"
          },
          "input_skill": "Bootstrap",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web UI \u0026 Integration Frameworks",
            "id": 268,
            "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
            "slug": "web-ui-integration-frameworks",
            "source": "db"
          },
          "input_skill": "Bootstrap",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Bootstrap",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "React",
          "alias_type": "CANONICAL",
          "id": 1047,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 0.13",
          "alias_type": "VERSION",
          "id": 1052,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 0.14",
          "alias_type": "VERSION",
          "id": 1053,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 15",
          "alias_type": "VERSION",
          "id": 1048,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 15.x",
          "alias_type": "VERSION",
          "id": 1054,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 16",
          "alias_type": "VERSION",
          "id": 1049,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 16.x",
          "alias_type": "VERSION",
          "id": 1055,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 17",
          "alias_type": "VERSION",
          "id": 1050,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 17.x",
          "alias_type": "VERSION",
          "id": 1056,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 18",
          "alias_type": "VERSION",
          "id": 1051,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 18.x",
          "alias_type": "VERSION",
          "id": 1057,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React 19",
          "alias_type": "VERSION",
          "id": 2068,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React v15",
          "alias_type": "VERSION",
          "id": 3185,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React v16",
          "alias_type": "VERSION",
          "id": 3186,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React v17",
          "alias_type": "VERSION",
          "id": 3187,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "React v18",
          "alias_type": "VERSION",
          "id": 3188,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ReactJS 18",
          "alias_type": "VERSION",
          "id": 2074,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 15",
          "alias_type": "VERSION",
          "id": 2069,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 16",
          "alias_type": "VERSION",
          "id": 2070,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 17",
          "alias_type": "VERSION",
          "id": 2071,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 18",
          "alias_type": "VERSION",
          "id": 2072,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react 19",
          "alias_type": "VERSION",
          "id": 2073,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react15",
          "alias_type": "VERSION",
          "id": 3177,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react16",
          "alias_type": "VERSION",
          "id": 3178,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react17",
          "alias_type": "VERSION",
          "id": 3179,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "react18",
          "alias_type": "VERSION",
          "id": 3180,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "reactjs 18",
          "alias_type": "VERSION",
          "id": 2075,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "React",
        "id": 610,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react",
        "sub_category_id": 1072,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Application Frameworks \u0026 Libraries",
            "id": 451,
            "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
            "slug": "application-frameworks-libraries",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frontend Frameworks and Libraries",
            "id": 434,
            "rationale": "Utilizing modern JavaScript frameworks and Shopify libraries to build dynamic and interactive storefronts.",
            "slug": "frontend-frameworks-and-libraries",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Shopify Dev",
              "id": 230,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "shopify-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript for WordPress",
            "id": 329,
            "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
            "slug": "javascript-for-wordpress",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "WordPress Dev",
              "id": 227,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "wordpress-dev",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Component Architecture",
            "id": 302,
            "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
            "slug": "react-component-architecture",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "UI Frameworks and Rendering",
            "id": 115,
            "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
            "slug": "ui-frameworks-and-rendering",
            "source": "db"
          },
          "input_skill": "React",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "React",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Angular",
          "alias_type": "CANONICAL",
          "id": 1067,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 1",
          "alias_type": "VERSION",
          "id": 1068,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 1.x",
          "alias_type": "VERSION",
          "id": 1086,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 10",
          "alias_type": "VERSION",
          "id": 1077,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 11",
          "alias_type": "VERSION",
          "id": 1078,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 12",
          "alias_type": "VERSION",
          "id": 1079,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 13",
          "alias_type": "VERSION",
          "id": 1080,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 14",
          "alias_type": "VERSION",
          "id": 1081,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 15",
          "alias_type": "VERSION",
          "id": 1082,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 16",
          "alias_type": "VERSION",
          "id": 1083,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 17",
          "alias_type": "VERSION",
          "id": 1084,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 2",
          "alias_type": "VERSION",
          "id": 1069,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 2+",
          "alias_type": "VERSION",
          "id": 1085,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 4",
          "alias_type": "VERSION",
          "id": 1070,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 5",
          "alias_type": "VERSION",
          "id": 1071,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 6",
          "alias_type": "VERSION",
          "id": 1072,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 7",
          "alias_type": "VERSION",
          "id": 1073,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 8",
          "alias_type": "VERSION",
          "id": 1074,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Angular 9",
          "alias_type": "VERSION",
          "id": 1075,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "AngularJS",
          "alias_type": "VERSION",
          "id": 1076,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 1",
          "alias_type": "VERSION",
          "id": 3205,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 1.x",
          "alias_type": "VERSION",
          "id": 3208,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 10",
          "alias_type": "VERSION",
          "id": 2098,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 11",
          "alias_type": "VERSION",
          "id": 2099,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 12",
          "alias_type": "VERSION",
          "id": 2100,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 13",
          "alias_type": "VERSION",
          "id": 2101,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 14",
          "alias_type": "VERSION",
          "id": 2102,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 15",
          "alias_type": "VERSION",
          "id": 2103,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 16",
          "alias_type": "VERSION",
          "id": 2104,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 17",
          "alias_type": "VERSION",
          "id": 2105,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 18",
          "alias_type": "VERSION",
          "id": 4019,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 19",
          "alias_type": "VERSION",
          "id": 4020,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 2",
          "alias_type": "VERSION",
          "id": 2089,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 2+",
          "alias_type": "VERSION",
          "id": 2106,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 2.x",
          "alias_type": "VERSION",
          "id": 3209,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 3",
          "alias_type": "VERSION",
          "id": 2090,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 4",
          "alias_type": "VERSION",
          "id": 2091,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 5",
          "alias_type": "VERSION",
          "id": 2092,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 6",
          "alias_type": "VERSION",
          "id": 2093,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 7",
          "alias_type": "VERSION",
          "id": 2094,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 8",
          "alias_type": "VERSION",
          "id": 2095,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular 9",
          "alias_type": "VERSION",
          "id": 2096,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular17",
          "alias_type": "VERSION",
          "id": 2097,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angular2",
          "alias_type": "VERSION",
          "id": 3204,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "angularjs",
          "alias_type": "VERSION",
          "id": 3207,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ng",
          "alias_type": "VERSION",
          "id": 2088,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ng1",
          "alias_type": "VERSION",
          "id": 3202,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ng2",
          "alias_type": "VERSION",
          "id": 3203,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Angular",
        "id": 612,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "angular",
        "sub_category_id": 1072,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Angular Component Model and Templates",
            "id": 303,
            "rationale": "Core Angular framework surface for building reusable UI, composing views, and wiring component behavior. This is the main application substrate for browser features in this role.",
            "slug": "angular-component-model-and-templates",
            "source": "db"
          },
          "input_skill": "AngularJS",
          "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": "Application Frameworks \u0026 Libraries",
            "id": 451,
            "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
            "slug": "application-frameworks-libraries",
            "source": "db"
          },
          "input_skill": "AngularJS",
          "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": "UI Frameworks and Rendering",
            "id": 115,
            "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
            "slug": "ui-frameworks-and-rendering",
            "source": "db"
          },
          "input_skill": "AngularJS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "AngularJS",
      "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": "Vue.js",
          "alias_type": "CANONICAL",
          "id": 4689,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue",
          "alias_type": "VERSION",
          "id": 4690,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue 2",
          "alias_type": "VERSION",
          "id": 4693,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue 2.x",
          "alias_type": "VERSION",
          "id": 4696,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue 3",
          "alias_type": "VERSION",
          "id": 4694,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue.js 2",
          "alias_type": "VERSION",
          "id": 4699,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue.js 3",
          "alias_type": "VERSION",
          "id": 4700,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue.js2",
          "alias_type": "VERSION",
          "id": 4697,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue2",
          "alias_type": "VERSION",
          "id": 4691,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue2.x",
          "alias_type": "VERSION",
          "id": 4695,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vue3",
          "alias_type": "VERSION",
          "id": 4692,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "vuejs 3",
          "alias_type": "VERSION",
          "id": 4698,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Vue.js",
        "id": 3201,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "vue-js",
        "sub_category_id": 1072,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frameworks \u0026 Libraries",
            "id": 360,
            "rationale": "The PHP frameworks and JavaScript libraries commonly employed within Drupal projects for building features and integrations.",
            "slug": "frameworks-libraries",
            "source": "db"
          },
          "input_skill": "Vue.js",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Drupal Dev",
              "id": 228,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "drupal-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Vue.js",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Node.js",
          "alias_type": "CANONICAL",
          "id": 2500,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node 20 LTS",
          "alias_type": "VERSION",
          "id": 2508,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node 20.x",
          "alias_type": "VERSION",
          "id": 2506,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node.js 20",
          "alias_type": "VERSION",
          "id": 2505,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node.js 20 LTS",
          "alias_type": "VERSION",
          "id": 2509,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Node.js 20.x",
          "alias_type": "VERSION",
          "id": 2507,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node",
          "alias_type": "VERSION",
          "id": 2501,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 10",
          "alias_type": "VERSION",
          "id": 3786,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 12",
          "alias_type": "VERSION",
          "id": 3787,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 14",
          "alias_type": "VERSION",
          "id": 3788,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 16",
          "alias_type": "VERSION",
          "id": 3789,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 18",
          "alias_type": "VERSION",
          "id": 3790,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node 20",
          "alias_type": "VERSION",
          "id": 2503,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v10",
          "alias_type": "VERSION",
          "id": 3793,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v12",
          "alias_type": "VERSION",
          "id": 3794,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v14",
          "alias_type": "VERSION",
          "id": 3795,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v16",
          "alias_type": "VERSION",
          "id": 3796,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v18",
          "alias_type": "VERSION",
          "id": 3797,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node v20",
          "alias_type": "VERSION",
          "id": 3798,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js",
          "alias_type": "VERSION",
          "id": 3792,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 10",
          "alias_type": "VERSION",
          "id": 3805,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 12",
          "alias_type": "VERSION",
          "id": 3806,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 14",
          "alias_type": "VERSION",
          "id": 3807,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 16",
          "alias_type": "VERSION",
          "id": 3808,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 18",
          "alias_type": "VERSION",
          "id": 3809,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "node.js 20",
          "alias_type": "VERSION",
          "id": 3810,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs",
          "alias_type": "VERSION",
          "id": 2502,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 10",
          "alias_type": "VERSION",
          "id": 3799,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 12",
          "alias_type": "VERSION",
          "id": 3800,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 14",
          "alias_type": "VERSION",
          "id": 3801,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 16",
          "alias_type": "VERSION",
          "id": 3802,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 18",
          "alias_type": "VERSION",
          "id": 3803,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "nodejs 20",
          "alias_type": "VERSION",
          "id": 2504,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 67,
        "display_name": "Node.js",
        "id": 1564,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "RUNTIME",
        "slug": "node-js",
        "sub_category_id": 1872,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript and TypeScript",
            "id": 114,
            "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
            "slug": "javascript-and-typescript",
            "source": "db"
          },
          "input_skill": "Node.js",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Web Application Frameworks",
            "id": 2,
            "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
            "slug": "web-application-frameworks",
            "source": "db"
          },
          "input_skill": "Node.js",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Node.js",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "REST",
          "alias_type": "CANONICAL",
          "id": 106,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "REST",
        "id": 11,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "rest",
        "sub_category_id": 2122,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Design and Contracts",
            "id": 3,
            "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
            "slug": "api-design-and-contracts",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "API Interface and Contract Design",
            "id": 289,
            "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
            "slug": "api-interface-and-contract-design",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Integration Protocols \u0026 Standards",
            "id": 271,
            "rationale": "Standards and protocols for integrating Pega applications.",
            "slug": "integration-protocols-standards",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Standards \u0026 Protocols Compliance",
            "id": 452,
            "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
            "slug": "standards-protocols-compliance",
            "source": "db"
          },
          "input_skill": "REST",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "REST",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "SOAP",
          "alias_type": "CANONICAL",
          "id": 211,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 10,
        "display_name": "SOAP",
        "id": 70,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "soap",
        "sub_category_id": 2347,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "External System Integrations",
            "id": 14,
            "rationale": "Connecting backend services to third-party APIs and internal enterprise systems. This includes client libraries, webhooks, retries, data mapping, and integration failure handling.",
            "slug": "external-system-integrations",
            "source": "db"
          },
          "input_skill": "SOAP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Drupal Dev",
              "id": 228,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "drupal-dev",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Integration Protocols \u0026 Standards",
            "id": 271,
            "rationale": "Standards and protocols for integrating Pega applications.",
            "slug": "integration-protocols-standards",
            "source": "db"
          },
          "input_skill": "SOAP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Pega Developer",
              "id": 24,
              "rationale": null,
              "role_archetype": null,
              "slug": "pega-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Standards \u0026 Protocols Compliance",
            "id": 452,
            "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
            "slug": "standards-protocols-compliance",
            "source": "db"
          },
          "input_skill": "SOAP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "SOAP",
      "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": "Git",
          "alias_type": "CANONICAL",
          "id": 1613,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Git",
        "id": 1002,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "git",
        "sub_category_id": 730,
        "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": "Git",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Git",
      "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": "Bitbucket",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Version Control Systems",
          "skill_nature": "PLATFORM",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "bitbucket",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "MariaDB",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Databases",
          "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": "mariadb",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "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": [
        {
          "alias_text": "Oracle Database",
          "alias_type": "CANONICAL",
          "id": 2512,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "Oracle Database",
        "id": 1566,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "oracle-database",
        "sub_category_id": 29,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Oracle Database",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Relational Database Design",
            "id": 4,
            "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
            "slug": "relational-database-design",
            "source": "db"
          },
          "input_skill": "Oracle Database",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Oracle Database",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "OpenShift",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Container Orchestration",
          "skill_nature": "PLATFORM",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "openshift",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Kubernetes",
          "alias_type": "CANONICAL",
          "id": 1267,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubernetes 1.0+",
          "alias_type": "VERSION",
          "id": 1271,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubernetes 1.x",
          "alias_type": "VERSION",
          "id": 1270,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Kubernetes v1",
          "alias_type": "VERSION",
          "id": 1269,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "k8s",
          "alias_type": "VERSION",
          "id": 1268,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kubernetes 1.x",
          "alias_type": "VERSION",
          "id": 1400,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kubernetes latest",
          "alias_type": "VERSION",
          "id": 1401,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "Kubernetes",
        "id": 726,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "kubernetes",
        "sub_category_id": 557,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Container Orchestration Platforms",
            "id": 134,
            "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
            "slug": "container-orchestration-platforms",
            "source": "db"
          },
          "input_skill": "Kubernetes",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Kubernetes for ML Workloads",
            "id": 47,
            "rationale": "Kubernetes-native components used to schedule, accelerate, and isolate ML training and serving workloads. This includes GPU enablement and ML-specific controllers rather than generic cluster administration.",
            "slug": "kubernetes-for-ml-workloads",
            "source": "db"
          },
          "input_skill": "Kubernetes",
          "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"
            }
          ]
        }
      ],
      "input_skill": "Kubernetes",
      "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": "Docker",
          "alias_type": "CANONICAL",
          "id": 198,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Docker",
        "id": 61,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "docker",
        "sub_category_id": 63,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Containerization and Image Builds",
            "id": 152,
            "rationale": "Container image creation, tagging, hardening, and registry workflows used to package services for deployment. This is coherent because DevOps often owns the build-to-image path that feeds runtime environments.",
            "slug": "containerization-and-image-builds",
            "source": "db"
          },
          "input_skill": "Docker",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Cloud Platforms",
            "id": 418,
            "rationale": "Platform-as-a-Service and container environments for deploying Ruby applications.",
            "slug": "deployment-and-cloud-platforms",
            "source": "db"
          },
          "input_skill": "Docker",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Runtime Configuration",
            "id": 13,
            "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
            "slug": "deployment-and-runtime-configuration",
            "source": "db"
          },
          "input_skill": "Docker",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Docker",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "AWS",
          "alias_type": "CANONICAL",
          "id": 406,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "AWS",
        "id": 187,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "aws",
        "sub_category_id": 46,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            },
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Go Backend Developer",
              "id": 81,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "go-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "MLOps Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms for AI Deployment",
            "id": 211,
            "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
            "slug": "cloud-platforms-for-ai-deployment",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Provider Platforms",
            "id": 131,
            "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
            "slug": "cloud-provider-platforms",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Posture Tools",
            "id": 64,
            "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
            "slug": "cloud-security-posture-tools",
            "source": "db"
          },
          "input_skill": "AWS",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            },
            {
              "display_name": "Cyber Security Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "AWS",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Hive",
          "alias_type": "CANONICAL",
          "id": 4198,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "Hive",
        "id": 2754,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "hive",
        "sub_category_id": 2242,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Local Persistence and Offline Behavior",
            "id": 85,
            "rationale": "On-device storage used for caching, offline support, and durable client state. This cluster is coherent because iOS apps often need to preserve user progress and data when connectivity is limited.",
            "slug": "local-persistence-and-offline-behavior",
            "source": "db"
          },
          "input_skill": "Hive",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Flutter Developer",
              "id": 74,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "flutter-developer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            },
            {
              "display_name": "iOS Developer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Hive",
      "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": "Impala",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Databases",
          "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": "impala",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Apache Spark",
          "alias_type": "CANONICAL",
          "id": 2004,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "apache spark 3",
          "alias_type": "VERSION",
          "id": 2006,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "spark",
          "alias_type": "VERSION",
          "id": 2510,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "spark 3",
          "alias_type": "VERSION",
          "id": 2007,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "spark 3.x",
          "alias_type": "VERSION",
          "id": 2009,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "spark3",
          "alias_type": "VERSION",
          "id": 2008,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Apache Spark",
        "id": 1350,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "apache-spark",
        "sub_category_id": 1021,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "ETL and ELT Tooling",
            "id": 24,
            "rationale": "Packaged tools for extracting, loading, and transforming data across systems. This dimension covers connector-based ingestion, transformation frameworks, and managed integration products.",
            "slug": "etl-and-elt-tooling",
            "source": "db"
          },
          "input_skill": "Spark",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Spark",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Amazon DynamoDB",
          "alias_type": "CANONICAL",
          "id": 254,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 11,
        "display_name": "Amazon DynamoDB",
        "id": 93,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CLOUD_SERVICE",
        "slug": "amazon-dynamodb",
        "sub_category_id": 55,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "NoSQL Databases",
            "id": 19,
            "rationale": "Models and manages data using non-relational database systems.",
            "slug": "nosql-databases",
            "source": "db"
          },
          "input_skill": "DynamoDB",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "DynamoDB",
      "matched_via": "embedding_display_name",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "MongoDB",
          "alias_type": "CANONICAL",
          "id": 232,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 2.0",
          "alias_type": "VERSION",
          "id": 238,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 2.2",
          "alias_type": "VERSION",
          "id": 239,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 2.4",
          "alias_type": "VERSION",
          "id": 240,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 2.6",
          "alias_type": "VERSION",
          "id": 241,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 3.0",
          "alias_type": "VERSION",
          "id": 242,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 3.2",
          "alias_type": "VERSION",
          "id": 243,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 3.4",
          "alias_type": "VERSION",
          "id": 244,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 3.6",
          "alias_type": "VERSION",
          "id": 245,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 4",
          "alias_type": "VERSION",
          "id": 233,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 4.0",
          "alias_type": "VERSION",
          "id": 246,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 4.2",
          "alias_type": "VERSION",
          "id": 247,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 4.4",
          "alias_type": "VERSION",
          "id": 248,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 5",
          "alias_type": "VERSION",
          "id": 234,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 5.0",
          "alias_type": "VERSION",
          "id": 249,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 6",
          "alias_type": "VERSION",
          "id": 235,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 6.0",
          "alias_type": "VERSION",
          "id": 250,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 7",
          "alias_type": "VERSION",
          "id": 236,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 7.0",
          "alias_type": "VERSION",
          "id": 251,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 8",
          "alias_type": "VERSION",
          "id": 237,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "MongoDB 8.0",
          "alias_type": "VERSION",
          "id": 252,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "MongoDB",
        "id": 91,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mongodb",
        "sub_category_id": 27,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "NoSQL Databases",
            "id": 19,
            "rationale": "Models and manages data using non-relational database systems.",
            "slug": "nosql-databases",
            "source": "db"
          },
          "input_skill": "MongoDB",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "MongoDB",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Cassandra",
          "alias_type": "CANONICAL",
          "id": 2013,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "Cassandra",
        "id": 1354,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "cassandra",
        "sub_category_id": 31,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Storage and Data Services",
            "id": 144,
            "rationale": "Cloud-native storage and managed data services used to place workloads, choose durability tiers, and define platform boundaries. This is a coherent cluster because architects evaluate storage fit, access patterns, and managed service tradeoffs.",
            "slug": "cloud-storage-and-data-services",
            "source": "db"
          },
          "input_skill": "Cassandra",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Cassandra",
      "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": "HBase",
          "alias_type": "CANONICAL",
          "id": 2011,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "HBase",
        "id": 1352,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "hbase",
        "sub_category_id": 31,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Storage and Data Services",
            "id": 144,
            "rationale": "Cloud-native storage and managed data services used to place workloads, choose durability tiers, and define platform boundaries. This is a coherent cluster because architects evaluate storage fit, access patterns, and managed service tradeoffs.",
            "slug": "cloud-storage-and-data-services",
            "source": "db"
          },
          "input_skill": "HBase",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "HBase",
      "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": "Agile",
          "alias_type": "CANONICAL",
          "id": 868,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Agile",
        "id": 520,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "agile",
        "sub_category_id": 367,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Agile",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Agile",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Continuous Integration",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Practices",
          "skill_nature": "PRACTICE",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "continuous-integration",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Release Automation",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Practices",
          "skill_nature": "PRACTICE",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "release-automation",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "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
    }
  ],
  "unmatched_skills": [
    "Spring Integration",
    "Spring Batch",
    "Spring Cloud",
    "MyBatis",
    "Linux",
    "Unix",
    "JMS",
    "Bitbucket",
    "MariaDB",
    "OpenShift",
    "Impala",
    "Continuous Integration",
    "Release Automation"
  ]
}
API 3 — final-role-output
{
  "chosen_role": {
    "display_name": "Fullstack Developer",
    "id": 15,
    "rationale": "Multi-alias tie (3 roles at 1.0) resolved by TIER_A_KRA: Fullstack Developer",
    "role_archetype": null,
    "slug": "full-stack-engineer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "Java",
      "tag": "in_db"
    },
    {
      "skill": "Spring Boot",
      "tag": "in_db"
    },
    {
      "skill": "Spring Security",
      "tag": "in_db"
    },
    {
      "skill": "Spring Integration",
      "tag": "new"
    },
    {
      "skill": "Spring Batch",
      "tag": "new"
    },
    {
      "skill": "Spring Data",
      "tag": "in_db"
    },
    {
      "skill": "Spring Cloud",
      "tag": "new"
    },
    {
      "skill": "JPA",
      "tag": "in_db"
    },
    {
      "skill": "Hibernate",
      "tag": "in_db"
    },
    {
      "skill": "MyBatis",
      "tag": "new"
    },
    {
      "skill": "Linux",
      "tag": "new"
    },
    {
      "skill": "Unix",
      "tag": "new"
    },
    {
      "skill": "SQL",
      "tag": "in_db"
    },
    {
      "skill": "JMS",
      "tag": "new"
    },
    {
      "skill": "Kafka",
      "tag": "in_db"
    },
    {
      "skill": "HTML5",
      "tag": "in_db"
    },
    {
      "skill": "CSS",
      "tag": "in_db"
    },
    {
      "skill": "JavaScript",
      "tag": "in_db"
    },
    {
      "skill": "ES6",
      "tag": "in_db"
    },
    {
      "skill": "jQuery",
      "tag": "in_db"
    },
    {
      "skill": "Bootstrap",
      "tag": "in_db"
    },
    {
      "skill": "React",
      "tag": "in_db"
    },
    {
      "skill": "AngularJS",
      "tag": "in_db"
    },
    {
      "skill": "Vue.js",
      "tag": "in_db"
    },
    {
      "skill": "Node.js",
      "tag": "in_db"
    },
    {
      "skill": "REST",
      "tag": "in_db"
    },
    {
      "skill": "SOAP",
      "tag": "in_db"
    },
    {
      "skill": "Git",
      "tag": "in_db"
    },
    {
      "skill": "Bitbucket",
      "tag": "new"
    },
    {
      "skill": "MariaDB",
      "tag": "new"
    },
    {
      "skill": "MySQL",
      "tag": "in_db"
    },
    {
      "skill": "Oracle Database",
      "tag": "in_db"
    },
    {
      "skill": "OpenShift",
      "tag": "new"
    },
    {
      "skill": "Kubernetes",
      "tag": "in_db"
    },
    {
      "skill": "Docker",
      "tag": "in_db"
    },
    {
      "skill": "AWS",
      "tag": "in_db"
    },
    {
      "skill": "Hive",
      "tag": "in_db"
    },
    {
      "skill": "Impala",
      "tag": "new"
    },
    {
      "skill": "Spark",
      "tag": "in_db"
    },
    {
      "skill": "DynamoDB",
      "tag": "in_db"
    },
    {
      "skill": "MongoDB",
      "tag": "in_db"
    },
    {
      "skill": "Cassandra",
      "tag": "in_db"
    },
    {
      "skill": "HBase",
      "tag": "in_db"
    },
    {
      "skill": "Agile",
      "tag": "in_db"
    },
    {
      "skill": "Continuous Integration",
      "tag": "new"
    },
    {
      "skill": "Release Automation",
      "tag": "new"
    },
    {
      "skill": "Unit Testing",
      "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": 15,
        "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": 15,
        "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": 15,
        "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Pega Programming Languages \u0026 DSLs",
          "id": 267,
          "rationale": "Programming languages and domain-specific languages used in Pega development.",
          "slug": "pega-programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 267,
        "input_skill": "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "Java",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Data Work",
          "id": 21,
          "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
          "slug": "programming-languages-for-data-work",
          "source": "db"
        },
        "dimension_id": 21,
        "input_skill": "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web Application Frameworks",
          "id": 2,
          "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
          "slug": "web-application-frameworks",
          "source": "db"
        },
        "dimension_id": 2,
        "input_skill": "Spring Boot",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 6,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web Service Frameworks",
          "id": 390,
          "rationale": "Server-side Kotlin frameworks and runtimes used to build HTTP services, middleware, controllers, and request pipelines. This cluster is the main entry point for backend endpoints and service behavior.",
          "slug": "web-service-frameworks",
          "source": "db"
        },
        "dimension_id": 390,
        "input_skill": "Spring Boot",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 6,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Authentication and Authorization",
          "id": 6,
          "rationale": "Identity, session, and access-control mechanisms used to protect PHP backend resources. This includes login flows, token handling, role checks, permissions, and policy enforcement in server-side code.",
          "slug": "authentication-and-authorization",
          "source": "db"
        },
        "dimension_id": 6,
        "input_skill": "Spring Security",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2234,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Backend Authentication and Authorization",
          "id": 386,
          "rationale": "Identity and access control mechanisms used by backend services to authenticate users or clients and enforce permissions on protected resources. This includes token and session handling, OAuth 2.0 / OpenID Connect / SAML flows, JWT and access tokens, API keys, MFA, role- or claim-based authorization, RBAC/ABAC, scopes, policies, Spring Security, and authorization filters.",
          "slug": "backend-authentication-and-authorization",
          "source": "db"
        },
        "dimension_id": 386,
        "input_skill": "Spring Security",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2234,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "ORMs and Data Access Layers",
          "id": 5,
          "rationale": "Libraries and patterns used to map application objects to persistent storage and encapsulate database access. This cluster covers repository patterns, query builders, and persistence abstractions.",
          "slug": "orms-and-data-access-layers",
          "source": "db"
        },
        "dimension_id": 5,
        "input_skill": "Spring Data",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 3557,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Application ORM and Repository-Based Data Access",
          "id": 459,
          "rationale": "Libraries, patterns, and abstractions used in application service code to map objects/entities to relational databases and encapsulate persistence access. This includes ORM frameworks, repository/DAO patterns, entity/object mapping, query composition/execution, transactions, and connection handling across Scala and Java ecosystems (for example Slick, Doobie, Quill, Hibernate, JPA, Spring Data JPA, JPQL, and Criteria-style query APIs).",
          "slug": "application-orm-and-repository-based-data-access",
          "source": "db"
        },
        "dimension_id": 459,
        "input_skill": "JPA",
        "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": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2196,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "ORMs and Data Access Layers",
          "id": 5,
          "rationale": "Libraries and patterns used to map application objects to persistent storage and encapsulate database access. This cluster covers repository patterns, query builders, and persistence abstractions.",
          "slug": "orms-and-data-access-layers",
          "source": "db"
        },
        "dimension_id": 5,
        "input_skill": "JPA",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2196,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Application ORM and Repository-Based Data Access",
          "id": 459,
          "rationale": "Libraries, patterns, and abstractions used in application service code to map objects/entities to relational databases and encapsulate persistence access. This includes ORM frameworks, repository/DAO patterns, entity/object mapping, query composition/execution, transactions, and connection handling across Scala and Java ecosystems (for example Slick, Doobie, Quill, Hibernate, JPA, Spring Data JPA, JPQL, and Criteria-style query APIs).",
          "slug": "application-orm-and-repository-based-data-access",
          "source": "db"
        },
        "dimension_id": 459,
        "input_skill": "Hibernate",
        "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": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 21,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "ORMs and Data Access Layers",
          "id": 5,
          "rationale": "Libraries and patterns used to map application objects to persistent storage and encapsulate database access. This cluster covers repository patterns, query builders, and persistence abstractions.",
          "slug": "orms-and-data-access-layers",
          "source": "db"
        },
        "dimension_id": 5,
        "input_skill": "Hibernate",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 21,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Pega Programming Languages \u0026 DSLs",
          "id": 267,
          "rationale": "Programming languages and domain-specific languages used in Pega development.",
          "slug": "pega-programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 267,
        "input_skill": "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for Data Work",
          "id": 21,
          "rationale": "Languages used to implement data pipelines, transformations, and operational glue. This is the primary coding surface for building ingestion, enrichment, and automation logic in data engineering.",
          "slug": "programming-languages-for-data-work",
          "source": "db"
        },
        "dimension_id": 21,
        "input_skill": "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
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Asynchronous Messaging and Event Streaming",
          "id": 297,
          "rationale": "Asynchronous communication patterns and broker technologies used to decouple backend services and move work off the request path. Includes queues, pub/sub, event streams, consumer groups, dead-letter queues, and delivery semantics across systems such as Kafka, RabbitMQ, NATS, SQS/SNS, Pulsar, and ActiveMQ.",
          "slug": "asynchronous-messaging-and-event-streaming",
          "source": "db"
        },
        "dimension_id": 297,
        "input_skill": "Kafka",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 36,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Messaging and Background Jobs",
          "id": 291,
          "rationale": "Asynchronous processing patterns and worker systems used to decouple backend work from request handling. This is a coherent cluster because the role supports background jobs, retries, and deferred processing.",
          "slug": "messaging-and-background-jobs",
          "source": "db"
        },
        "dimension_id": 291,
        "input_skill": "Kafka",
        "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": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 36,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Messaging and Event Streaming",
          "id": 8,
          "rationale": "Transport-layer systems used to move events and decouple producers from consumers. Data engineers use these systems to ingest, buffer, and distribute event data before downstream processing.",
          "slug": "messaging-and-event-streaming",
          "source": "db"
        },
        "dimension_id": 8,
        "input_skill": "Kafka",
        "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": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 36,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web Standards \u0026 Compliance",
          "id": 343,
          "rationale": "Ensuring WordPress sites adhere to web markup, styling, accessibility, and privacy regulations.",
          "slug": "web-standards-compliance",
          "source": "db"
        },
        "dimension_id": 343,
        "input_skill": "HTML5",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "WordPress Dev",
            "id": 227,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "wordpress-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 3087,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 Template Languages",
          "id": 359,
          "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
          "slug": "programming-languages-template-languages",
          "source": "db"
        },
        "dimension_id": 359,
        "input_skill": "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "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": 15,
        "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": 15,
        "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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "JavaScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript and TypeScript",
          "id": 114,
          "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
          "slug": "javascript-and-typescript",
          "source": "db"
        },
        "dimension_id": 114,
        "input_skill": "JavaScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript for WordPress",
          "id": 329,
          "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
          "slug": "javascript-for-wordpress",
          "source": "db"
        },
        "dimension_id": 329,
        "input_skill": "JavaScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "WordPress Dev",
            "id": 227,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "wordpress-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Pega Programming Languages \u0026 DSLs",
          "id": 267,
          "rationale": "Programming languages and domain-specific languages used in Pega development.",
          "slug": "pega-programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 267,
        "input_skill": "JavaScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Pega Developer",
            "id": 24,
            "rationale": null,
            "role_archetype": null,
            "slug": "pega-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "JavaScript",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 Template Languages",
          "id": 359,
          "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
          "slug": "programming-languages-template-languages",
          "source": "db"
        },
        "dimension_id": 359,
        "input_skill": "JavaScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "JavaScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Storefront JavaScript and DOM Behavior",
          "id": 422,
          "rationale": "Client-side behavior used to enhance Shopify storefront interactions beyond static theme rendering. This includes interactive UI logic, event handling, and progressive enhancement within theme constraints.",
          "slug": "storefront-javascript-and-dom-behavior",
          "source": "db"
        },
        "dimension_id": 422,
        "input_skill": "JavaScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Shopify Dev",
            "id": 230,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "shopify-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "ES6",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript and TypeScript",
          "id": 114,
          "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
          "slug": "javascript-and-typescript",
          "source": "db"
        },
        "dimension_id": 114,
        "input_skill": "ES6",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript for WordPress",
          "id": 329,
          "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
          "slug": "javascript-for-wordpress",
          "source": "db"
        },
        "dimension_id": 329,
        "input_skill": "ES6",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "WordPress Dev",
            "id": 227,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "wordpress-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Pega Programming Languages \u0026 DSLs",
          "id": 267,
          "rationale": "Programming languages and domain-specific languages used in Pega development.",
          "slug": "pega-programming-languages-dsls",
          "source": "db"
        },
        "dimension_id": 267,
        "input_skill": "ES6",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Pega Developer",
            "id": 24,
            "rationale": null,
            "role_archetype": null,
            "slug": "pega-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "ES6",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages \u0026 Template Languages",
          "id": 359,
          "rationale": "The languages and domain-specific templating languages used for Drupal development and theming.",
          "slug": "programming-languages-template-languages",
          "source": "db"
        },
        "dimension_id": 359,
        "input_skill": "ES6",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "ES6",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Storefront JavaScript and DOM Behavior",
          "id": 422,
          "rationale": "Client-side behavior used to enhance Shopify storefront interactions beyond static theme rendering. This includes interactive UI logic, event handling, and progressive enhancement within theme constraints.",
          "slug": "storefront-javascript-and-dom-behavior",
          "source": "db"
        },
        "dimension_id": 422,
        "input_skill": "ES6",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Shopify Dev",
            "id": 230,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "shopify-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 607,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Application Frameworks \u0026 Libraries",
          "id": 451,
          "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
          "slug": "application-frameworks-libraries",
          "source": "db"
        },
        "dimension_id": 451,
        "input_skill": "jQuery",
        "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": 1968,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Frameworks \u0026 Libraries",
          "id": 360,
          "rationale": "The PHP frameworks and JavaScript libraries commonly employed within Drupal projects for building features and integrations.",
          "slug": "frameworks-libraries",
          "source": "db"
        },
        "dimension_id": 360,
        "input_skill": "jQuery",
        "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": 1968,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript Checkout Behavior",
          "id": 393,
          "rationale": "Client-side behavior used to customize Magento storefront interactions, especially checkout and account flows. This includes Magento\u0027s browser-side component model and form behavior where commerce logic is implemented in the UI.",
          "slug": "javascript-checkout-behavior",
          "source": "db"
        },
        "dimension_id": 393,
        "input_skill": "jQuery",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Magento Dev",
            "id": 231,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "magento-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1968,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Storefront JavaScript and DOM Behavior",
          "id": 422,
          "rationale": "Client-side behavior used to enhance Shopify storefront interactions beyond static theme rendering. This includes interactive UI logic, event handling, and progressive enhancement within theme constraints.",
          "slug": "storefront-javascript-and-dom-behavior",
          "source": "db"
        },
        "dimension_id": 422,
        "input_skill": "jQuery",
        "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": 1968,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web UI \u0026 Integration Frameworks",
          "id": 268,
          "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
          "slug": "web-ui-integration-frameworks",
          "source": "db"
        },
        "dimension_id": 268,
        "input_skill": "jQuery",
        "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": 1968,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Component Libraries and Design Systems",
          "id": 118,
          "rationale": "Reusable UI kits and design-system implementations that standardize look, feel, and interaction patterns across products. This is a distinct cluster because frontend engineers frequently consume and extend these libraries.",
          "slug": "component-libraries-and-design-systems",
          "source": "db"
        },
        "dimension_id": 118,
        "input_skill": "Bootstrap",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1970,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web UI \u0026 Integration Frameworks",
          "id": 268,
          "rationale": "Client-side and integration frameworks and libraries used to extend Pega solutions.",
          "slug": "web-ui-integration-frameworks",
          "source": "db"
        },
        "dimension_id": 268,
        "input_skill": "Bootstrap",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Pega Developer",
            "id": 24,
            "rationale": null,
            "role_archetype": null,
            "slug": "pega-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1970,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Application Frameworks \u0026 Libraries",
          "id": 451,
          "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
          "slug": "application-frameworks-libraries",
          "source": "db"
        },
        "dimension_id": 451,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Frontend Frameworks and Libraries",
          "id": 434,
          "rationale": "Utilizing modern JavaScript frameworks and Shopify libraries to build dynamic and interactive storefronts.",
          "slug": "frontend-frameworks-and-libraries",
          "source": "db"
        },
        "dimension_id": 434,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Shopify Dev",
            "id": 230,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "shopify-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript for WordPress",
          "id": 329,
          "rationale": "Client-side scripting used to enhance WordPress themes, blocks, and admin/editor interactions. This includes modern JavaScript patterns as they apply to WordPress-specific behavior rather than standalone frontend applications.",
          "slug": "javascript-for-wordpress",
          "source": "db"
        },
        "dimension_id": 329,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "WordPress Dev",
            "id": 227,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "wordpress-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Component Architecture",
          "id": 302,
          "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
          "slug": "react-component-architecture",
          "source": "db"
        },
        "dimension_id": 302,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "UI Frameworks and Rendering",
          "id": 115,
          "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
          "slug": "ui-frameworks-and-rendering",
          "source": "db"
        },
        "dimension_id": 115,
        "input_skill": "React",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 610,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Angular Component Model and Templates",
          "id": 303,
          "rationale": "Core Angular framework surface for building reusable UI, composing views, and wiring component behavior. This is the main application substrate for browser features in this role.",
          "slug": "angular-component-model-and-templates",
          "source": "db"
        },
        "dimension_id": 303,
        "input_skill": "AngularJS",
        "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": 612,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Application Frameworks \u0026 Libraries",
          "id": 451,
          "rationale": "Covers the primary software frameworks and libraries often used alongside Sitecore for building and enhancing site experiences.",
          "slug": "application-frameworks-libraries",
          "source": "db"
        },
        "dimension_id": 451,
        "input_skill": "AngularJS",
        "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": 612,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "UI Frameworks and Rendering",
          "id": 115,
          "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
          "slug": "ui-frameworks-and-rendering",
          "source": "db"
        },
        "dimension_id": 115,
        "input_skill": "AngularJS",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 612,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Frameworks \u0026 Libraries",
          "id": 360,
          "rationale": "The PHP frameworks and JavaScript libraries commonly employed within Drupal projects for building features and integrations.",
          "slug": "frameworks-libraries",
          "source": "db"
        },
        "dimension_id": 360,
        "input_skill": "Vue.js",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 3201,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript and TypeScript",
          "id": 114,
          "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
          "slug": "javascript-and-typescript",
          "source": "db"
        },
        "dimension_id": 114,
        "input_skill": "Node.js",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1564,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Web Application Frameworks",
          "id": 2,
          "rationale": "Server frameworks and runtimes used to build HTTP services, controllers, middleware, and request pipelines. These frameworks shape how backend endpoints are structured and delivered.",
          "slug": "web-application-frameworks",
          "source": "db"
        },
        "dimension_id": 2,
        "input_skill": "Node.js",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1564,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Design and Contracts",
          "id": 3,
          "rationale": "Designing request/response shapes and the rules that govern client-server interaction. This cluster is coherent because full stack engineers often own the contract between UI behavior and backend implementation.",
          "slug": "api-design-and-contracts",
          "source": "db"
        },
        "dimension_id": 3,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "API Interface and Contract Design",
          "id": 289,
          "rationale": "Designing backend service interfaces and contracts that other systems consume, including endpoint and operation shape, request/response payloads, schema and validation, pagination, filtering, idempotency, versioning, status codes, and backward compatibility across REST, GraphQL, gRPC, and OpenAPI-based APIs.",
          "slug": "api-interface-and-contract-design",
          "source": "db"
        },
        "dimension_id": 289,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Integration Protocols \u0026 Standards",
          "id": 271,
          "rationale": "Standards and protocols for integrating Pega applications.",
          "slug": "integration-protocols-standards",
          "source": "db"
        },
        "dimension_id": 271,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Pega Developer",
            "id": 24,
            "rationale": null,
            "role_archetype": null,
            "slug": "pega-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Standards \u0026 Protocols Compliance",
          "id": 452,
          "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
          "slug": "standards-protocols-compliance",
          "source": "db"
        },
        "dimension_id": 452,
        "input_skill": "REST",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 11,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "External System Integrations",
          "id": 14,
          "rationale": "Connecting backend services to third-party APIs and internal enterprise systems. This includes client libraries, webhooks, retries, data mapping, and integration failure handling.",
          "slug": "external-system-integrations",
          "source": "db"
        },
        "dimension_id": 14,
        "input_skill": "SOAP",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 70,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Integration Protocols \u0026 Standards",
          "id": 271,
          "rationale": "Standards and protocols for integrating Pega applications.",
          "slug": "integration-protocols-standards",
          "source": "db"
        },
        "dimension_id": 271,
        "input_skill": "SOAP",
        "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": 70,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Standards \u0026 Protocols Compliance",
          "id": 452,
          "rationale": "Encompasses key web and data standards, protocols, and compliance requirements relevant to Sitecore implementations.",
          "slug": "standards-protocols-compliance",
          "source": "db"
        },
        "dimension_id": 452,
        "input_skill": "SOAP",
        "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": 70,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Git",
        "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": 1002,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Data Modeling",
          "id": 216,
          "rationale": "Modeling and tuning relational persistence for backend features. PHP backend developers need this to shape schemas, indexes, transactions, and query-aware data structures that support application behavior.",
          "slug": "relational-data-modeling",
          "source": "db"
        },
        "dimension_id": 216,
        "input_skill": "MySQL",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Fullstack Developer",
            "id": 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": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Database Design",
          "id": 4,
          "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
          "slug": "relational-database-design",
          "source": "db"
        },
        "dimension_id": 4,
        "input_skill": "MySQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 17,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Database Usage",
          "id": 371,
          "rationale": "Working effectively with operational relational databases from Go backend services. This includes schema-aware querying, indexing awareness, transactions, and understanding how service code interacts with PostgreSQL or similar systems.",
          "slug": "relational-database-usage",
          "source": "db"
        },
        "dimension_id": 371,
        "input_skill": "MySQL",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 17,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Oracle Database",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1566,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Relational Database Design",
          "id": 4,
          "rationale": "Modeling and operating relational persistence for backend services. Includes schema design, normalization, indexing, transactions, and query tuning for operational data stores.",
          "slug": "relational-database-design",
          "source": "db"
        },
        "dimension_id": 4,
        "input_skill": "Oracle Database",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1566,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Container Orchestration Platforms",
          "id": 134,
          "rationale": "Platforms that schedule and manage containerized workloads across clusters and environments. Cloud Architects need these to define workload placement standards, cluster boundaries, and platform capabilities.",
          "slug": "container-orchestration-platforms",
          "source": "db"
        },
        "dimension_id": 134,
        "input_skill": "Kubernetes",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 726,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Kubernetes for ML Workloads",
          "id": 47,
          "rationale": "Kubernetes-native components used to schedule, accelerate, and isolate ML training and serving workloads. This includes GPU enablement and ML-specific controllers rather than generic cluster administration.",
          "slug": "kubernetes-for-ml-workloads",
          "source": "db"
        },
        "dimension_id": 47,
        "input_skill": "Kubernetes",
        "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": 726,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Containerization and Image Builds",
          "id": 152,
          "rationale": "Container image creation, tagging, hardening, and registry workflows used to package services for deployment. This is coherent because DevOps often owns the build-to-image path that feeds runtime environments.",
          "slug": "containerization-and-image-builds",
          "source": "db"
        },
        "dimension_id": 152,
        "input_skill": "Docker",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 61,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment and Cloud Platforms",
          "id": 418,
          "rationale": "Platform-as-a-Service and container environments for deploying Ruby applications.",
          "slug": "deployment-and-cloud-platforms",
          "source": "db"
        },
        "dimension_id": 418,
        "input_skill": "Docker",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 61,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Deployment and Runtime Configuration",
          "id": 13,
          "rationale": "Configuration and release artifacts that control how backend services run in environments. Includes environment variables, manifests, feature flags, and release-safe configuration management.",
          "slug": "deployment-and-runtime-configuration",
          "source": "db"
        },
        "dimension_id": 13,
        "input_skill": "Docker",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 61,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms",
          "id": 20,
          "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
          "slug": "cloud-platforms",
          "source": "db"
        },
        "dimension_id": 20,
        "input_skill": "AWS",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          },
          {
            "display_name": "Data Engineer",
            "id": 2,
            "rationale": null,
            "role_archetype": null,
            "slug": "data-engineer",
            "source": "db"
          },
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Go Backend Developer",
            "id": 81,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "go-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          },
          {
            "display_name": "MLOps Engineer",
            "id": 16,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-ops-engineer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Platforms for AI Deployment",
          "id": 211,
          "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
          "slug": "cloud-platforms-for-ai-deployment",
          "source": "db"
        },
        "dimension_id": 211,
        "input_skill": "AWS",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AI Engineer",
            "id": 13,
            "rationale": null,
            "role_archetype": null,
            "slug": "ai-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Provider Platforms",
          "id": 131,
          "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
          "slug": "cloud-provider-platforms",
          "source": "db"
        },
        "dimension_id": 131,
        "input_skill": "AWS",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          },
          {
            "display_name": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Security Posture Tools",
          "id": 64,
          "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
          "slug": "cloud-security-posture-tools",
          "source": "db"
        },
        "dimension_id": 64,
        "input_skill": "AWS",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Security Engineer",
            "id": 23,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-security-engineer",
            "source": "db"
          },
          {
            "display_name": "Cyber Security Engineer",
            "id": 5,
            "rationale": null,
            "role_archetype": null,
            "slug": "cybersecurity-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 187,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Local Persistence and Offline Behavior",
          "id": 85,
          "rationale": "On-device storage used for caching, offline support, and durable client state. This cluster is coherent because iOS apps often need to preserve user progress and data when connectivity is limited.",
          "slug": "local-persistence-and-offline-behavior",
          "source": "db"
        },
        "dimension_id": 85,
        "input_skill": "Hive",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Flutter Developer",
            "id": 74,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "flutter-developer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          },
          {
            "display_name": "iOS Developer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2754,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "ETL and ELT Tooling",
          "id": 24,
          "rationale": "Packaged tools for extracting, loading, and transforming data across systems. This dimension covers connector-based ingestion, transformation frameworks, and managed integration products.",
          "slug": "etl-and-elt-tooling",
          "source": "db"
        },
        "dimension_id": 24,
        "input_skill": "Spark",
        "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": 1350,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "NoSQL Databases",
          "id": 19,
          "rationale": "Models and manages data using non-relational database systems.",
          "slug": "nosql-databases",
          "source": "db"
        },
        "dimension_id": 19,
        "input_skill": "DynamoDB",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Skipped \u2014 no persistable v3 meta for new skill",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": false,
        "skill_id": null,
        "skill_tag": "new",
        "skipped_reason": "skill_not_in_db_v3_proposed"
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "NoSQL Databases",
          "id": 19,
          "rationale": "Models and manages data using non-relational database systems.",
          "slug": "nosql-databases",
          "source": "db"
        },
        "dimension_id": 19,
        "input_skill": "MongoDB",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 91,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Storage and Data Services",
          "id": 144,
          "rationale": "Cloud-native storage and managed data services used to place workloads, choose durability tiers, and define platform boundaries. This is a coherent cluster because architects evaluate storage fit, access patterns, and managed service tradeoffs.",
          "slug": "cloud-storage-and-data-services",
          "source": "db"
        },
        "dimension_id": 144,
        "input_skill": "Cassandra",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1354,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cloud Storage and Data Services",
          "id": 144,
          "rationale": "Cloud-native storage and managed data services used to place workloads, choose durability tiers, and define platform boundaries. This is a coherent cluster because architects evaluate storage fit, access patterns, and managed service tradeoffs.",
          "slug": "cloud-storage-and-data-services",
          "source": "db"
        },
        "dimension_id": 144,
        "input_skill": "HBase",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Cloud Architect",
            "id": 9,
            "rationale": null,
            "role_archetype": null,
            "slug": "cloud-architect",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1352,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Agile",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 520,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 15,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Unit Testing",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 517,
        "skill_tag": "in_db",
        "skipped_reason": null
      }
    ],
    "new_skills_created": 0,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 0,
    "skipped": 1
  },
  "planner_output": null,
  "run_id": "2f41f803-2392-4fba-bac3-8ea9ed2a2eb1"
}

LLM Calls

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

Loading…