← Back to history

Pipeline run

a7b376ec-51ce-4870-bafe-d39125c7a090

Pipeline LLM cost (USD)
API 1: $0.0049 API 2: $0.2075 API 3: $0.0000 Total: $0.2123

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 · API and backend integration
Build and document small-to-medium Java cloud modules, add UI and backend features, and integrate systems using Spring Boot/microservices, CI/CD, IaC, and teamwork in agile ceremonies. Support code reviews, testing, and release feedback while adapting to shifting priorities.
"Work across teams to integrate our systems with existing corporate product platforms."
Tech stack maturity
Mainstream Modern cache hit
The skill set centers on widely used modern enterprise technologies like Spring Boot, microservices, CI/CD, and major cloud platforms, which fits a mainstream modern stack rather than bleeding-edge or legacy.
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 (36)
Java GCP AWS Azure HTML JavaScript Angular Bootstrap J2EE Spring Boot SOA Microservices SVN Git GitHub Maven Gradle Scrum XP SQL Server MySQL JIRA Confluence JDK JUnit +11
Skill cluster (11 dimension groups, role-scoped)
Cloud Provider Platforms
GCP AWS Azure
Java Language and JVM
Java JDK
Angular Component Model and Templates
Angular
Build and Dependency Management
Maven
Build and Release Tooling
Gradle
CI/CD Pipeline Platforms
DevOps
Component Libraries and Design Systems
Bootstrap
Cross-Platform App Languages
JavaScript
Relational Database Usage
MySQL
Web Service Frameworks
Spring Boot
Cross-cutting / unaligned
HTML J2EE SOA Microservices SVN Git GitHub Scrum XP SQL Server JIRA Confluence JUnit Selenium LoadRunner SoapUI Serverless Computing CI/CD Infrastructure as Code Agile Design Patterns SecOps FinOps
Show KRA description ↓
Design requirements on small systems or modules of medium systems (large scale) environment and technical documentation. Apply basic principles of software engineering and can follow instructions. Provide meaningful feedback on the release process, code review, and design review. Easily absorbs and applies new information. Displays a cooperative attitude and shares knowledge. Apply modern software development practices (serverless computing, microservices architecture, CI/CD, infrastructure-as-code, etc.). Work across teams to integrate our systems with existing corporate product platforms. Participate in technology roadmap and architecture discussions to turn business requirements and vision into reality. Participate in a tight-knit engineering team employing agile software development practices. Leverage automation within scope of effort. 6 months+ experience with Java software programming experience 6 months+ experience with Cloud technology: GCP, AWS, or Azure Self-starter that identifies/responds to priority shifts with minimal supervision UI development (e.g. HTML, JavaScript, Angular and Bootstrap) Experience with backend technologies such as JAVA/J2EE, SpringBoot, SOA and Microservices Source code control management systems (e.g. SVN/Git, Github) and build tools like Maven & Gradle. Agile environments (e.g. Scrum, XP) Relational databases (e.g. SQL Server, MySQL) Atlassian tooling (e.g. JIRA, Confluence, and Github) Developing with modern JDK (v1.7+) Automated Testing: JUnit, Selenium, LoadRunner, SoapUI. An ability to demonstrate successful performance of our Success Profile skills, including: Agile Engineering Best Practices - Has basic knowledge of managing timely delivery of assigned engineering tasks and reporting status within agile ceremonies. Engineering Design - Has basic knowledge of design patterns and software engineering development lifecycle. Has basic knowledge of devops, SecOps and FinOps practices and levers that help to build effective, efficient and safe working software that meets business goals. Engineering Requirement Analysis - Has basic knowledge of decomposing business requirements into tactical software engineering task. Idea Creation - Has basic knowledge of business value creation through software engineering and continues to be curious about achieving the goals with more efficient ways. Industry Knowledge - Has basic knowledge about latest trends within software engineering fields and how it applies to role and responsibilities tactical goals. Systems Thinking - Has basic knowledge of how systems integrate with others. Assists in identifying factors that achieve the defined expectations of systems availability.

Signals

Skill backend-engineer
0.28
Alias android-engineer
0.69
KRA devops-engineer
0.61

Post-classification

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

Captured for admin review

Bootstrap primary Ios engineer pending
SOA primary Ios engineer pending
SVN primary Ios engineer pending
XP primary Ios engineer pending
JIRA primary Ios engineer pending
Confluence primary Ios engineer pending
JDK primary Ios engineer pending
JUnit primary Ios engineer pending
Selenium primary Ios engineer pending
LoadRunner primary Ios engineer pending
SoapUI primary Ios engineer pending
Serverless Computing primary Ios engineer pending
Infrastructure as Code primary Ios engineer pending
SecOps Ios engineer pending
Status: extract_details_done Created: 2026-05-21T13:14:07.135853Z Updated: 2026-05-21T13:16:27.855743Z
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

Full Stack Engineer

CASE A

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

The primary skills listed encompass both front-end and back-end technologies, making Full Stack Engineer the most fitting title.

Job description

About the job
Equifax is seeking creative, high-energy and driven software engineers with hands-on development skills to work on a variety of meaningful projects. Our  software engineering positions  provide you the opportunity to join a team of talented engineers working with leading-edge technology. You are ideal for this position if you are a forward-thinking, committed, and enthusiastic software engineer who is passionate about technology.

What You’ll Do

 Design requirements on small systems or modules of medium systems (large scale) environment and technical documentation. 
 Apply basic principles of software engineering and can follow instructions. Provide meaningful feedback on the release process, code review, and design review. 
 Easily absorbs and applies new information. Displays a cooperative attitude and shares knowledge. 
 Apply modern software development practices (serverless computing, microservices architecture, CI/CD, infrastructure-as-code, etc.). Work across teams to integrate our systems with existing corporate product platforms 
 Participate in technology roadmap and architecture discussions to turn business requirements and vision into reality. 
 Participate in a tight-knit engineering team employing agile software development practices. Leverage automation within scope of effort 

What Experience You Need

 Bachelor's degree or equivalent experience 
 6 months+ experience with Java software programming experience 
 6 months+ experience with Cloud technology: GCP, AWS, or Azure 
 Self-starter that identifies/responds to priority shifts with minimal supervision 
 UI development (e.g. HTML, JavaScript, Angular and Bootstrap) 
 Experience with backend technologies such as JAVA/J2EE, SpringBoot, SOA and Microservices 
 Source code control management systems (e.g. SVN/Git, Github) and build tools like Maven & Gradle. 
 Agile environments (e.g. Scrum, XP) 
 Relational databases (e.g. SQL Server, MySQL) 
 Atlassian tooling (e.g. JIRA, Confluence, and Github) 
 Developing with modern JDK (v1.7+) 
 Automated Testing: JUnit, Selenium, LoadRunner, SoapUI 

  What could set you apart  

An ability to demonstrate successful performance of our Success Profile skills, including:

 Agile Engineering Best Practices - Has basic knowledge of managing timely delivery of assigned engineering tasks and reporting status within agile ceremonies 
 Engineering Design - Has basic knowledge of design patterns and software engineering development lifecycle. Has basic knowledge of devops, SecOps and FinOps practices and levers that help to build effective, efficient and safe working software that meets business goals 
 Engineering Requirement Analysis - Has basic knowledge of decomposing business requirements into tactical software engineering task 
 Idea Creation - Has basic knowledge of business value creation through software engineering and continues to be curious about achieving the goals with more efficient ways 
 Industry Knowledge - Has basic knowledge about latest trends within software engineering fields and how it applies to role and responsibilities tactical goals. 
 Systems Thinking - Has basic knowledge of how systems integrate with others. Assists in identifying factors that achieve the defined expectations of systems availability.

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 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)

  • Kotlin and Java Catalog dimension db id 161

    Library dimension (catalog)

    Roles linked in library: Android Engineer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Full Stack Engineer

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

GCP Primary Library skill Existing skill (matched library)
Canonical: GCP id=186 · gcp

Aliases — catalog

  • GCP (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cloud Platforms Catalog dimension db id 20

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, Full Stack Engineer, ML Engineer, ML Ops Engineer

  • 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, Cybersecurity Engineer

AWS Primary Library skill 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: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, Full Stack Engineer, ML Engineer, ML Ops Engineer

  • 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, Cybersecurity Engineer

Azure Primary Library skill Existing skill (matched library)
Canonical: Azure id=188 · azure

Aliases — catalog

  • Azure (CANONICAL) primary

Context tags (catalog)

AKS ARM templates App Service Azure AD Azure Active Directory Azure App Service Azure Blob Azure Blob Storage Azure Cognitive Services Azure Cosmos DB Azure DevOps Azure DevTest Labs Azure Functions Azure Kubernetes Service Azure Logic Apps Azure Monitor Azure Networking Azure Resource Manager Azure SQL Azure SQL Database Azure Security Center Azure Storage Azure Storage Explorer Azure Virtual Machines Bicep Blob Storage Cloud Services Cosmos DB Entra ID Functions Infrastructure as Code Key Vault Log Analytics Logic Apps Resource Groups Serverless Computing Service Bus Storage Account Terraform Virtual Machines

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Cloud Platform
Vendor
Microsoft
License
proprietary
Year introduced
2010
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Azure is broadly adopted and frequently appears in cloud/platform job descriptions alongside AWS and GCP; Microsoft’s ongoing enterprise investment and Azure certification demand signal strong hiring-pipeline relevance.

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: Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, Full Stack Engineer, ML Engineer, ML Ops Engineer

  • Cloud Platforms & Managed Services Catalog dimension db id 221

    Library dimension (catalog)

    Roles linked in library: Full Stack Engineer

  • 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, Cybersecurity Engineer

HTML Primary Library skill Existing skill (matched library)
Canonical: HTML id=1657 · html

Aliases — catalog

  • HTML (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

JavaScript Primary Library skill 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: Frontend Engineer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Full Stack Engineer

Angular Primary Library skill 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)

  • UI Frameworks and Rendering Catalog dimension db id 115

    Library dimension (catalog)

    Roles linked in library: Frontend Engineer, Full Stack Engineer, Hybrid Mobile Developer

Bootstrap Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Bootstrap remains widely listed in job descriptions for responsive UI work and is still heavily used in existing web stacks; GitHub activity and CDN usage show sustained demand, not a sunset replacement.

Vendor & license

Twitter ·mit ·since 2011 (0.95)

Context keywords
responsive design grid system Sass jQuery components modals navigation utilities customization themes Bootstrap 5 flexbox card layout form controls media queries
Ambiguity low

“Bootstrap” in JDs typically refers to the Bootstrap CSS framework; other meanings are uncommon in this context.

Versioning

Versioned 5

{
  "bootstrap 5": "5",
  "bootstrap 5.x": "5",
  "bootstrap v5": "5",
  "bootstrap5": "5",
  "bs5": "5"
}
Type assignment

Framework ·css_framework confidence 0.97

Bootstrap is a frontend framework because developers build applications and UIs with it rather than merely using it as standalone software.

Derived legacy fields
Category
Framework
Sub-category
css_framework
Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
SEPARATE_ENTITY

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Systems Programming Catalog dimension db id 166

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Frontend Application Bootstrap

    Pipeline tentative id

    Initial setup and scaffolding for browser-based applications, including project startup, app wiring, and first-screen composition. Bootstrap belongs here when it refers to the UI framework or starter structure used to launch a frontend app.

  • Bootstrap CSS Framework

    Pipeline tentative id

    The Bootstrap front-end framework for building responsive layouts, reusable UI components, and utility-driven styling. This dimension fits when Bootstrap means the popular CSS/JS framework rather than generic startup or initialization.

J2EE Primary Library skill Existing skill (matched library)
Canonical: J2EE id=1565 · j2ee

Aliases — catalog

  • J2EE (CANONICAL)

Context tags (catalog)

EJB GlassFish Hibernate JDBC JNDI JSF JSP Java EE Maven Microservices RESTful SOAP Servlets Spring WebLogic

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Enterprise Java Framework
Vendor
Oracle
License
other_open
Year introduced
1999
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: J2EE is largely superseded by Jakarta EE/Spring in modern JDs; Oracle’s Java EE/J2EE branding was replaced and current job postings rarely ask for J2EE specifically.

Skill profile (library / DB)

Skill nature
FRAMEWORK
Volatility
DEPRECATED
Typical lifespan
SHORT_LIVED
Category id
5
Sub-category id
1172
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 Engineer, Full Stack Engineer

Spring Boot Primary Library skill 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 Engineer, Full Stack Engineer

SOA Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.78

SOA remains a common architecture term in enterprise JDs and vendor docs, though often framed as legacy/transition toward microservices rather than a new niche skill.

Vendor & license

(0.90)

Context keywords
microservices RESTful services SOAP WSDL ESB API gateway service registry message broker service orchestration service composition loose coupling interoperability scalability service contract business process management
Ambiguity flagged

Could be confused with: microservices, event_driven_architecture

SOA is often mentioned alongside or confused with other service-based architectures like microservices or event-driven architecture in JDs.

Versioning

Not versioned

Type assignment

Architecture ·service_oriented_architecture confidence 0.98

SOA is a system-shape pattern for structuring applications as services, so by the Architecture vs Concept rule it is an Architecture.

Derived legacy fields
Category
Architecture
Sub-category
service_oriented_architecture
Skill nature
PATTERN
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Service-Oriented Architecture

    Pipeline tentative id

    Architectural style for designing systems as loosely coupled services with explicit contracts and composable boundaries. SOA belongs here because it refers to the service-based decomposition and integration approach rather than a specific framework or platform.

Microservices Primary Library skill Existing skill (matched library)
Canonical: microservices id=41 · microservices

Aliases — catalog

  • microservices (CANONICAL) primary

Context tags (catalog)

API Gateway API gateway CQRS DevOps Docker Kubernetes REST API RESTful services Saga pattern Spring Boot circuit breaker containerization decentralized distributed tracing domain-driven design event sourcing event-driven event-driven architecture gRPC load balancing message broker microservices patterns monitoring scalability service discovery service mesh

Stored enrichment (catalog DB)

Category
Architecture
Sub-category
Distributed System Architecture
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: Microservices is a common architecture in job descriptions across backend/cloud roles, and major vendors like AWS, Google Cloud, and Kubernetes ecosystems provide first-class support and reference patterns.

Skill profile (library / DB)

Skill nature
PATTERN
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
1
Sub-category id
1
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • Microservices and Distributed Systems Catalog dimension db id 9

    Library dimension (catalog)

    Roles linked in library: Backend Engineer

SVN Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.93

SVN still appears in some legacy enterprise JDs, but Git dominates hiring pipelines and new repos; GitHub/GitLab market share and repo activity signal far higher demand for Git-based workflows.

Vendor & license

Apache Software Foundation ·apache_2 ·since 2000 (0.95)

Context keywords
repository commit checkout merge branching trunk revision conflict resolution diff update SVN client subversion tags working copy remote repository
Ambiguity low

“SVN” most commonly refers to Subversion, a version control tool; unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Tool ·version_control_tool confidence 0.97

SVN is software users run to manage source control locally or against a server, so by the Tool vs Framework rule it is a Tool rather than a Framework or Platform.

Derived legacy fields
Category
Tool
Sub-category
version_control_tool
Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Model and Data Versioning Catalog dimension db id 48

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

  • Model and Data Versioning Catalog dimension db id 48

    Library dimension (catalog)

    Roles linked in library: ML Engineer, ML Ops Engineer

Locked dimensions (v3 placement)

  • Model and Data Versioning

    Reuses catalog slug

    Version control practices for datasets, artifacts, and related project assets that need reproducibility and rollback. SVN fits here as a source control system used to track changes, manage revisions, and coordinate shared work on code or assets.

  • Model and Data Versioning

    Reuses catalog slug

    Versioning systems for datasets, features, and model artifacts at the storage layer. This enables reproducible training, rollback, lineage of artifacts, and controlled promotion of model assets.

Git Primary Library skill 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)

GitHub Primary Library skill Existing skill (matched library)
Canonical: GitHub id=280 · github

Aliases — catalog

  • GitHub (CANONICAL) primary

Context tags (catalog)

CI/CD Git GitHub Actions GitHub Enterprise GitHub Pages SSH keys actions branch protection branches code review collaboration commit history fork forking issue tracker issues markdown merge conflicts merge request pull request pull requests release tags repositories repository version control webhooks

Stored enrichment (catalog DB)

Category
Platform
Sub-category
Devops Platform
Vendor
GitHub, Inc.
License
other_open
Year introduced
2008
Confidence
0.96
Version strategy
NOT_APPLICABLE

Maturity reasoning: GitHub appears in a very high volume of engineering JDs for source control, code review, and CI/CD; it’s a standard hiring-pipeline skill across teams.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

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

    Library dimension (catalog)

    Roles linked in library: ML Engineer

Maven Primary Library skill Existing skill (matched library)
Canonical: Maven id=815 · maven

Aliases — catalog

  • Maven (CANONICAL) primary

Context tags (catalog)

CI/CD JAR Java Maven Central artifact build automation build lifecycle dependency management integration testing multi-module plugins pom.xml project object model release management repository site generation versioning

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Build Tool
Vendor
Apache Software Foundation
License
apache_2
Year introduced
2004
Confidence
0.95
Version strategy
NOT_APPLICABLE

Maturity reasoning: Maven remains a standard Java build tool, appearing in many Java/JVM job descriptions and widely used in enterprise CI/CD pipelines alongside Gradle.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Build and Packaging Tooling Catalog dimension db id 149

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

Gradle Primary Library skill Existing skill (matched library)
Canonical: Gradle id=816 · gradle

Aliases — catalog

  • Gradle (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Build and Packaging Tooling Catalog dimension db id 149

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Build and Release Tooling Catalog dimension db id 89

    Library dimension (catalog)

    Roles linked in library: Android Engineer, Hybrid Mobile Developer, Ios engineer

Scrum Primary Library skill Existing skill (matched library)
Canonical: Scrum id=1215 · scrum

Aliases — catalog

  • Scrum (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Scrum
Confidence
0.99
Version strategy
NOT_APPLICABLE

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

XP Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.82

XP appears in some agile/JD listings, but far less often than Scrum/Kanban; market demand is limited and usually folded into broader Agile experience rather than requested standalone.

Vendor & license

(0.95)

Context keywords
pair programming test-driven development continuous integration refactoring user stories agile practices sprint planning collaborative coding feedback loops release planning code reviews collective code ownership simple design sustainable pace customer involvement
Ambiguity flagged

Could be confused with: xps, experience_points

“XP” is commonly used for Experience Points or XPS (XML Paper Specification), not just Extreme Programming.

Versioning

Not versioned

Type assignment

Methodology ·extreme_programming confidence 0.98

XP refers to Extreme Programming, which is a way of working and therefore fits the Concept vs Methodology rule as a Methodology.

Derived legacy fields
Category
Methodology
Sub-category
extreme_programming
Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Extreme Programming Practices

    Pipeline tentative id

    Software development practices associated with XP, emphasizing rapid feedback, close collaboration, and disciplined engineering habits. This skill belongs here because XP is a named methodology centered on how teams build software day to day.

SQL Server Primary Library skill Existing skill (matched library)
Canonical: SQL Server id=18 · sql-server

Aliases — catalog

  • SQL Server (CANONICAL) primary
  • SQL Server 2000 (VERSION)
  • SQL Server 2005 (VERSION)
  • SQL Server 2008 (VERSION)
  • SQL Server 2012 (VERSION)
  • SQL Server 2014 (VERSION)
  • SQL Server 2016 (VERSION)
  • SQL Server 2017 (VERSION)
  • SQL Server 2019 (VERSION)
  • SQL Server 2022 (VERSION)
  • SQL Server 6.5 (VERSION)
  • SQL Server 7.0 (VERSION)

Context tags (catalog)

Always On CLR Integration Clustered Index ETL Execution Plan Linked Servers Query Store Replication SQL Agent SQL Server Agent SQL Server Integration Services SQL Server Management Studio SQL Server Reporting Services SSIS SSMS SSRS Stored Procedures T-SQL TempDB backup and recovery backup and restore clustering data migration data warehousing database design database normalization indexing performance tuning query optimization replication stored procedures transaction log transaction logs

Stored enrichment (catalog DB)

Category
Datastore
Sub-category
Relational Database
Vendor
Microsoft
License
proprietary
Year introduced
1989
Confidence
0.99
Version strategy
NOT_APPLICABLE

Maturity reasoning: SQL Server appears in many enterprise job descriptions and remains a major Microsoft-supported RDBMS with active Azure SQL/SQL Server demand; it is a common hiring-pipeline staple, not a sunset technology.

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 Database Design Catalog dimension db id 4

    Library dimension (catalog)

    Roles linked in library: Backend Engineer

MySQL Primary Library skill 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: Full Stack Engineer

  • Relational Database Design Catalog dimension db id 4

    Library dimension (catalog)

    Roles linked in library: Backend Engineer

JIRA Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.97

JIRA appears in a large share of software job descriptions for issue tracking and agile workflows, and Atlassian continues active product support with broad enterprise adoption.

Vendor & license

Atlassian ·other_open ·since 2002 (0.95)

Context keywords
Agile Scrum Kanban backlog sprint issue tracking workflow epics user stories burndown roadmap release planning custom fields JQL dashboard
Ambiguity low

JIRA is a specific issue-tracking tool name; typical JDs won’t confuse it with other distinct skills in the catalog.

Versioning

Not versioned

Type assignment

Tool ·issue_tracking_tool confidence 0.98

JIRA is software you operate as a user for issue tracking and project management, so by the Tool vs Framework rule it is a Tool rather than a platform or framework.

Derived legacy fields
Category
Tool
Sub-category
issue_tracking_tool
Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Work Tracking and Issue Management

    Pipeline tentative id

    Tools and practices for tracking tasks, bugs, epics, workflows, and team execution across a project lifecycle. JIRA belongs here because it is commonly used to create, prioritize, assign, and monitor work items.

Confluence Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.93

Common in enterprise JDs for documentation/knowledge management; Atlassian reports broad adoption across teams, and it remains a standard collaboration platform rather than a niche tool.

Vendor & license

Atlassian ·unknown ·since 2004 (0.90)

Context keywords
Atlassian documentation collaboration knowledge base team spaces page templates macro version control permissions integrations project management workflow content organization user management cloud hosting
Ambiguity low

“Confluence” is a specific wiki/collaboration platform name; unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Platform ·wiki_collaboration_platform confidence 0.90

By the Vendor SaaS rule, Confluence is a hosted multi-tenant commercial SaaS product consumed via Atlassian's service, so it is a Platform rather than a Tool or Framework.

Derived legacy fields
Category
Platform
Sub-category
wiki_collaboration_platform
Skill nature
PLATFORM
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Documentation and Knowledge Management

    Pipeline tentative id

    Tools and practices for creating, organizing, and sharing team knowledge, project docs, and operational runbooks. Confluence belongs here because it is commonly used as a collaborative documentation workspace rather than a coding or infrastructure tool.

JDK Primary Library skill 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)

  • Kotlin and Java Catalog dimension db id 161

    Library dimension (catalog)

    Roles linked in library: Android Engineer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

    Roles linked in library: Backend Engineer, Full Stack Engineer

  • Programming Languages for Data Work Catalog dimension db id 21

    Library dimension (catalog)

    Roles linked in library: Data Engineer

JUnit Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.97

JUnit is a standard Java testing framework and appears in many job descriptions for backend and QA roles; it remains a common hiring-pipeline staple alongside Maven/Gradle and CI.

Vendor & license

JUnit Team ·other_open ·since 2000 (0.90)

Context keywords
Mockito TestNG JUnit 5 assertions mocks integration testing unit tests annotations TDD code coverage JUnit 4 parameterized tests setup methods test suites exception testing
Ambiguity low

JUnit is a specific Java testing framework; unlikely to be confused with other catalog skills.

Versioning

Versioned 5

{
  "junit 4": "4",
  "junit 4.x": "4",
  "junit 5": "5",
  "junit 5.x": "5",
  "junit-jupiter": "5",
  "junit4": "4",
  "junit5": "5"
}
Type assignment

Framework ·testing_framework confidence 0.97

JUnit is a structured codebase that developers build and run tests within, so by the Tool vs Framework rule it is a Framework rather than a Tool or Library.

Derived legacy fields
Category
Framework
Sub-category
testing_framework
Skill nature
FRAMEWORK
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
SEPARATE_ENTITY

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Unit Testing Frameworks

    Pipeline tentative id

    Frameworks and conventions for writing automated unit tests, assertions, fixtures, and test runners. JUnit belongs here because it is a primary Java unit testing framework used to validate small code units in isolation.

Selenium Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.96

Selenium remains a hiring-pipeline staple for QA/E2E roles; it appears in many job descriptions and is still widely used across browser automation stacks, despite newer tools like Playwright gaining share.

Vendor & license

SeleniumHQ ·apache_2 ·since 2004 (0.95)

Context keywords
WebDriver TestNG JUnit Page Object Model Selenium Grid Cucumber JavaScript Python XPath CSS Selectors Headless Browsers Cross-Browser Testing Automation Framework Continuous Integration Behavior-Driven Development
Ambiguity low

Selenium is a specific, widely recognized test automation tool; typical JDs won’t confuse it with other catalog skills.

Versioning

Not versioned

Type assignment

Tool ·test_automation_tool confidence 0.98

Selenium is software you run to automate browsers, so by the Tool vs Framework rule it is a Tool rather than a framework or library.

Derived legacy fields
Category
Tool
Sub-category
test_automation_tool
Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Frontend Testing and E2E Automation Catalog dimension db id 122

    Library dimension (catalog)

    Roles linked in library: Frontend Engineer

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Frontend Testing and E2E Automation Catalog dimension db id 122

    Library dimension (catalog)

    Roles linked in library: Frontend Engineer

Locked dimensions (v3 placement)

  • Frontend Testing and E2E Automation

    Reuses catalog slug

    Testing tools and practices used to validate browser-based user flows, UI interactions, and end-to-end application behavior. Selenium belongs here because it automates real browser sessions to verify that web features work as users experience them.

  • Browser Automation Tooling

    Pipeline tentative id

    Tools and libraries used to drive browsers programmatically for testing, scraping, and scripted interaction. Selenium fits because it provides a general browser automation API and driver ecosystem beyond a single test framework.

  • Frontend Testing and E2E Automation

    Reuses catalog slug

    Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.

LoadRunner Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.88

LoadRunner appears in performance-testing JDs, but far less often than JMeter/k6; market demand is concentrated in legacy enterprise QA roles rather than broad hiring pipelines.

Vendor & license

Micro Focus ·proprietary ·since 1996 (0.95)

Context keywords
VUGen Controller Analysis Load Testing Performance Metrics Scripting Virtual Users Web Protocols LoadRunner Cloud Business Process Testing Monitoring Correlation Parameterization Performance Bottlenecks Test Scenarios
Ambiguity low

LoadRunner is a specific HP/ALM performance testing tool name; unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Tool ·performance_testing_tool confidence 0.98

LoadRunner is software you run to perform load and performance testing, so by the Tool vs Framework rule it is a Tool rather than a framework or platform.

Derived legacy fields
Category
Tool
Sub-category
performance_testing_tool
Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

Locked dimensions (v3 placement)

  • Performance Testing Tools

    Pipeline tentative id

    Tools used to simulate user load, measure response times, and validate system behavior under stress. LoadRunner belongs here because it is a dedicated performance testing platform for load, stress, and endurance testing.

SoapUI Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity niche confidence 0.87

SoapUI still appears in some API-testing job ads, but JD volume is far below Postman/REST Assured and the market has shifted toward those tools; SmartBear’s own focus is now on ReadyAPI/ReadyAPI Test.

Vendor & license

SmartBear Software ·apache_2 ·since 2005 (0.95)

Context keywords
API testing SOAP REST mock services load testing functional testing assertions test cases Groovy scripting data-driven testing service virtualization JUnit integration test automation report generation security testing
Ambiguity low

SoapUI is a specific API testing tool name; unlikely to be confused with other catalog skills.

Versioning

Not versioned

Type assignment

Tool ·api_testing_tool confidence 0.98

SoapUI is software you run to test and inspect APIs, so by the Tool vs Framework rule it is a Tool rather than something you build applications inside.

Derived legacy fields
Category
Tool
Sub-category
api_testing_tool
Skill nature
TOOL
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Frontend Testing and E2E Automation Catalog dimension db id 122

    Library dimension (catalog)

    Roles linked in library: Frontend Engineer

  • Frontend Testing and E2E Automation Catalog dimension db id 122

    Library dimension (catalog)

    Roles linked in library: Frontend Engineer

Locked dimensions (v3 placement)

  • Frontend Testing and E2E Automation

    Reuses catalog slug

    Tools and practices for validating application behavior through automated tests that exercise UI flows, integrations, and service interactions. SoapUI fits here because it is commonly used to test APIs and end-to-end request/response behavior that supports application quality.

  • Frontend Testing and E2E Automation

    Reuses catalog slug

    Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.

Serverless Computing Primary Library skill Existing skill (matched library)
Canonical: Serverless Framework id=800 · serverless-framework

Aliases — catalog

  • Serverless Framework (CANONICAL) primary

Context tags (catalog)

API Gateway AWS Lambda CI/CD CloudFormation DynamoDB IAM roles S3 SAM Step Functions YAML cold start deployment stages event-driven microservices serverless.yml

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Infrastructure As Code Framework
Vendor
Serverless, Inc.
License
mit
Year introduced
2015
Confidence
0.95
Version strategy
NOT_APPLICABLE

Maturity reasoning: Commonly listed in cloud/IaC job descriptions for AWS Lambda deployments; strong GitHub usage and vendor ecosystem support indicate broad adoption, though often alongside newer tools like SST/CDK.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Infrastructure as Code Catalog dimension db id 132

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

CI/CD Primary Library skill Existing skill (matched library)
Canonical: CI/CD id=1190 · ci-cd

Aliases — catalog

  • CI/CD (CANONICAL)

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

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

    Library dimension (catalog)

    Roles linked in library: ML Engineer

Infrastructure as Code Primary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.98

Infrastructure as Code is a hiring-pipeline staple: Terraform, CloudFormation, and Pulumi appear in many DevOps/SRE job descriptions, and major cloud vendors actively support it.

Vendor & license

(0.95)

Context keywords
Terraform Ansible CloudFormation IaC GitOps CI/CD DevOps Immutable Infrastructure Configuration Management Version Control Automation Microservices Containerization Infrastructure Provisioning Declarative Syntax
Ambiguity low

“Infrastructure as Code” is a distinct methodology; typical JDs won’t confuse it with other catalog skills.

Versioning

Not versioned

Type assignment

Methodology ·infrastructure_as_code confidence 0.91

By the Concept vs Methodology rule, Infrastructure as Code is a way of working for provisioning and managing infrastructure, not a software artifact or system shape.

Derived legacy fields
Category
Methodology
Sub-category
infrastructure_as_code
Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Infrastructure as Code Catalog dimension db id 132

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

  • Environment Provisioning and Parity Catalog dimension db id 157

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Security Architecture and Hardening Catalog dimension db id 75

    Library dimension (catalog)

    Roles linked in library: Cybersecurity Engineer

  • Environment Provisioning and Parity Catalog dimension db id 157

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Security Architecture and Hardening Catalog dimension db id 75

    Library dimension (catalog)

    Roles linked in library: Cybersecurity Engineer

Locked dimensions (v3 placement)

  • Infrastructure as Code

    Pipeline tentative id

    Declarative definition and automated provisioning of infrastructure using code and templates. This skill belongs here because it focuses on creating, updating, and reviewing cloud and platform resources through repeatable machine-readable definitions.

  • Environment Provisioning and Parity

    Reuses catalog slug

    Creating consistent development, test, staging, and production environments with repeatable setup. Infrastructure as Code belongs here when the emphasis is on making environments reproducible and aligned across stages.

  • Security Architecture and Hardening

    Reuses catalog slug

    Design and implementation of secure baselines, control patterns, and environment hardening across systems. Infrastructure as Code fits when it is used to codify secure infrastructure defaults, guardrails, and compliant resource configurations.

  • Environment Provisioning and Parity

    Reuses catalog slug

    Creating and maintaining consistent dev, test, staging, and production environments. This cluster is coherent because delivery failures often come from environment drift, missing dependencies, or inconsistent configuration.

  • Security Architecture and Hardening

    Reuses catalog slug

    Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.

Agile Primary Library skill 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)

Design Patterns Secondary Library skill Existing skill (matched library)
Canonical: design patterns id=1654 · design-patterns

Aliases — catalog

  • design patterns (CANONICAL)

Context tags (catalog)

Adapter Builder Command Composite Decorator Dependency Injection Facade Factory MVC Observer Prototype SOLID Singleton Strategy Visitor

Stored enrichment (catalog DB)

Category
Concept
Sub-category
Software Design Patterns
Confidence
0.94
Version strategy
NOT_APPLICABLE

Maturity reasoning: Design patterns are a standard interview/JD topic across backend and frontend roles; job postings commonly mention them alongside OOP and system design, and they remain core in books, courses, and code reviews.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

DevOps Secondary Library skill Existing skill (matched library)
Canonical: DevOps id=1216 · devops

Aliases — catalog

  • DevOps (CANONICAL)

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • CI/CD Pipeline Platforms Catalog dimension db id 150

    Library dimension (catalog)

    Roles linked in library: DevOps Engineer

  • Deployment and Release Patterns Catalog dimension db id 140

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

  • Infrastructure as Code Catalog dimension db id 132

    Library dimension (catalog)

    Roles linked in library: Cloud Architect, DevOps Engineer

SecOps Secondary New / orchestrated New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

Maturity well_known confidence 0.90

SecOps is broadly listed in security and DevOps job descriptions, with vendors like Microsoft, AWS, and Splunk offering SecOps products and training, indicating mainstream hiring demand.

Vendor & license

(0.95)

Context keywords
incident response threat hunting vulnerability management security monitoring SIEM firewall management malware analysis risk assessment compliance auditing penetration testing security orchestration automated response log analysis network segmentation endpoint protection
Ambiguity low

SecOps is a distinct security operations methodology; typical JDs won’t confuse it with other catalog skills.

Versioning

Not versioned

Type assignment

Methodology ·security_operations_methodology confidence 0.90

SecOps is fundamentally a way of working that integrates security into operations, so by the Concept vs Methodology rule it fits Methodology rather than a tool or platform.

Derived legacy fields
Category
Methodology
Sub-category
security_operations_methodology
Skill nature
METHODOLOGY
Volatility
STABLE
Typical lifespan
EVERGREEN
Version strategy
NOT_APPLICABLE

Dimensions (API 2 worklist)

  • Security Architecture and Hardening Catalog dimension db id 75

    Library dimension (catalog)

    Roles linked in library: Cybersecurity Engineer

  • Cloud Configuration Review Catalog dimension db id 244

    Library dimension (catalog)

    Roles linked in library: Cloud Security Engineer

  • Cloud Configuration Review Catalog dimension db id 244

    Library dimension (catalog)

    Roles linked in library: Cloud Security Engineer

  • Security Architecture and Hardening Catalog dimension db id 75

    Library dimension (catalog)

    Roles linked in library: Cybersecurity Engineer

Locked dimensions (v3 placement)

  • Security Operations Hardening

    Reuses catalog slug

    Operational security practices for securing systems, environments, and controls in day-to-day engineering work. SecOps fits here when it refers to applying security baselines, hardening, and secure operational guardrails across infrastructure and services.

  • Cloud Security Operations Review

    Reuses catalog slug

    Reviewing cloud resources and operational settings for security misconfigurations, drift, and control compliance. SecOps belongs here when it means continuously checking cloud posture and correcting risky configurations.

  • Cloud Configuration Review

    Reuses catalog slug

    Review practices for evaluating cloud resources against security baselines and approved control requirements. This includes reading configurations, identifying drift, and documenting remediation guidance for owning teams.

  • Security Architecture and Hardening

    Reuses catalog slug

    Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.

FinOps Secondary Library skill Existing skill (matched library)
Canonical: FinOps id=770 · finops

Aliases — catalog

  • FinOps (CANONICAL) primary

Context tags (catalog)

AWS Cost Explorer Azure Cost Management Google Cloud Billing Kubernetes cost allocation budget alerts chargeback cloud cost optimization cost allocation cost anomaly detection reserved instances rightsizing savings plans showback tagging strategy unit economics

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Cloud Finance Methodology
Confidence
0.96
Version strategy
NOT_APPLICABLE

Maturity reasoning: FinOps appears increasingly in cloud/finance job descriptions and vendor programs, but it’s still far less universal than core cloud skills; the FinOps Foundation’s rapid growth signals rising adoption.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cloud Cost and FinOps Catalog dimension db id 142

    Library dimension (catalog)

    Roles linked in library: Cloud Architect

Library artifacts (this run)

No artifact rows for this run.
nano JD Parser — gpt-4.1-nano click to toggle
RoleSoftware Engineer
CompanyEquifax
Experience6 months+ experience with Java software programming experience
DomainIT Services & Consulting
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": null,
  "certifications": [],
  "company_name": "Equifax",
  "ctc": null,
  "domain": {
    "primary": {
      "aliases": [
        "ITES",
        "BPO"
      ],
      "domain": "IT Services \u0026 Consulting"
    },
    "secondary": null
  },
  "education": [
    {
      "level": "Bachelor\u0027s",
      "qualification": "BTECH/BE/BSC - Any Discipline",
      "raw": "Bachelor\u0027s degree or equivalent experience",
      "requirement": "required"
    }
  ],
  "experience": {
    "max": null,
    "min": 0.5,
    "raw": "6 months+ experience with Java software programming experience"
  },
  "job_locations": [],
  "role": "Software Engineer",
  "role_aliases": [
    "Software Developer",
    "SWE",
    "Java Developer"
  ],
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 0,
      "heading": "What You\u2019ll Do",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Design requirements on small systems",
        "last_5_words": "within scope of effort."
      },
      "text": "Design requirements on small systems or modules of medium systems (large scale) environment and technical documentation.\nApply basic principles of software engineering and can follow instructions. Provide meaningful feedback on the release process, code review, and design review.\nEasily absorbs and applies new information. Displays a cooperative attitude and shares knowledge.\nApply modern software development practices (serverless computing, microservices architecture, CI/CD, infrastructure-as-code, etc.). Work across teams to integrate our systems with existing corporate product platforms.\nParticipate in technology roadmap and architecture discussions to turn business requirements and vision into reality.\nParticipate in a tight-knit engineering team employing agile software development practices. Leverage automation within scope of effort.",
      "word_count": 116
    },
    {
      "bullet_count": 11,
      "heading": "What Experience You Need",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "6 months+ experience with Java",
        "last_5_words": "JUnit, Selenium, LoadRunner, SoapUI."
      },
      "text": "6 months+ experience with Java software programming experience\n6 months+ experience with Cloud technology: GCP, AWS, or Azure\nSelf-starter that identifies/responds to priority shifts with minimal supervision\nUI development (e.g. HTML, JavaScript, Angular and Bootstrap)\nExperience with backend technologies such as JAVA/J2EE, SpringBoot, SOA and Microservices\nSource code control management systems (e.g. SVN/Git, Github) and build tools like Maven \u0026 Gradle.\nAgile environments (e.g. Scrum, XP)\nRelational databases (e.g. SQL Server, MySQL)\nAtlassian tooling (e.g. JIRA, Confluence, and Github)\nDeveloping with modern JDK (v1.7+)\nAutomated Testing: JUnit, Selenium, LoadRunner, SoapUI.",
      "word_count": 134
    },
    {
      "bullet_count": 0,
      "heading": "What could set you apart",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "An ability to demonstrate successful",
        "last_5_words": "defined expectations of systems availability."
      },
      "text": "An ability to demonstrate successful performance of our Success Profile skills, including:\nAgile Engineering Best Practices - Has basic knowledge of managing timely delivery of assigned engineering tasks and reporting status within agile ceremonies.\nEngineering Design - Has basic knowledge of design patterns and software engineering development lifecycle. Has basic knowledge of devops, SecOps and FinOps practices and levers that help to build effective, efficient and safe working software that meets business goals.\nEngineering Requirement Analysis - Has basic knowledge of decomposing business requirements into tactical software engineering task.\nIdea Creation - Has basic knowledge of business value creation through software engineering and continues to be curious about achieving the goals with more efficient ways.\nIndustry Knowledge - Has basic knowledge about latest trends within software engineering fields and how it applies to role and responsibilities tactical goals.\nSystems Thinking - Has basic knowledge of how systems integrate with others. Assists in identifying factors that achieve the defined expectations of systems availability.",
      "word_count": 164
    }
  ],
  "urls": []
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "Java"
    },
    {
      "is_primary": true,
      "skill_name": "GCP"
    },
    {
      "is_primary": true,
      "skill_name": "AWS"
    },
    {
      "is_primary": true,
      "skill_name": "Azure"
    },
    {
      "is_primary": true,
      "skill_name": "HTML"
    },
    {
      "is_primary": true,
      "skill_name": "JavaScript"
    },
    {
      "is_primary": true,
      "skill_name": "Angular"
    },
    {
      "is_primary": true,
      "skill_name": "Bootstrap"
    },
    {
      "is_primary": true,
      "skill_name": "J2EE"
    },
    {
      "is_primary": true,
      "skill_name": "Spring Boot"
    },
    {
      "is_primary": true,
      "skill_name": "SOA"
    },
    {
      "is_primary": true,
      "skill_name": "Microservices"
    },
    {
      "is_primary": true,
      "skill_name": "SVN"
    },
    {
      "is_primary": true,
      "skill_name": "Git"
    },
    {
      "is_primary": true,
      "skill_name": "GitHub"
    },
    {
      "is_primary": true,
      "skill_name": "Maven"
    },
    {
      "is_primary": true,
      "skill_name": "Gradle"
    },
    {
      "is_primary": true,
      "skill_name": "Scrum"
    },
    {
      "is_primary": true,
      "skill_name": "XP"
    },
    {
      "is_primary": true,
      "skill_name": "SQL Server"
    },
    {
      "is_primary": true,
      "skill_name": "MySQL"
    },
    {
      "is_primary": true,
      "skill_name": "JIRA"
    },
    {
      "is_primary": true,
      "skill_name": "Confluence"
    },
    {
      "is_primary": true,
      "skill_name": "JDK"
    },
    {
      "is_primary": true,
      "skill_name": "JUnit"
    },
    {
      "is_primary": true,
      "skill_name": "Selenium"
    },
    {
      "is_primary": true,
      "skill_name": "LoadRunner"
    },
    {
      "is_primary": true,
      "skill_name": "SoapUI"
    },
    {
      "is_primary": true,
      "skill_name": "Serverless Computing"
    },
    {
      "is_primary": true,
      "skill_name": "CI/CD"
    },
    {
      "is_primary": true,
      "skill_name": "Infrastructure as Code"
    },
    {
      "is_primary": true,
      "skill_name": "Agile"
    },
    {
      "is_primary": false,
      "skill_name": "Design Patterns"
    },
    {
      "is_primary": false,
      "skill_name": "DevOps"
    },
    {
      "is_primary": false,
      "skill_name": "SecOps"
    },
    {
      "is_primary": false,
      "skill_name": "FinOps"
    }
  ],
  "jd_role": {
    "display_name": "Software Engineer",
    "rationale": null,
    "role_aliases": [
      "Software Developer",
      "SWE",
      "Java Developer"
    ],
    "role_archetype": "Engineering",
    "slug": ""
  },
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": null,
    "certifications": [],
    "company_name": "Equifax",
    "ctc": null,
    "domain": {
      "primary": {
        "aliases": [
          "ITES",
          "BPO"
        ],
        "domain": "IT Services \u0026 Consulting"
      },
      "secondary": null
    },
    "education": [
      {
        "level": "Bachelor\u0027s",
        "qualification": "BTECH/BE/BSC - Any Discipline",
        "raw": "Bachelor\u0027s degree or equivalent experience",
        "requirement": "required"
      }
    ],
    "experience": {
      "max": null,
      "min": 0.5,
      "raw": "6 months+ experience with Java software programming experience"
    },
    "job_locations": [],
    "role": "Software Engineer",
    "role_aliases": [
      "Software Developer",
      "SWE",
      "Java Developer"
    ],
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 0,
        "heading": "What You\u2019ll Do",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Design requirements on small systems",
          "last_5_words": "within scope of effort."
        },
        "text": "Design requirements on small systems or modules of medium systems (large scale) environment and technical documentation.\nApply basic principles of software engineering and can follow instructions. Provide meaningful feedback on the release process, code review, and design review.\nEasily absorbs and applies new information. Displays a cooperative attitude and shares knowledge.\nApply modern software development practices (serverless computing, microservices architecture, CI/CD, infrastructure-as-code, etc.). Work across teams to integrate our systems with existing corporate product platforms.\nParticipate in technology roadmap and architecture discussions to turn business requirements and vision into reality.\nParticipate in a tight-knit engineering team employing agile software development practices. Leverage automation within scope of effort.",
        "word_count": 116
      },
      {
        "bullet_count": 11,
        "heading": "What Experience You Need",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "6 months+ experience with Java",
          "last_5_words": "JUnit, Selenium, LoadRunner, SoapUI."
        },
        "text": "6 months+ experience with Java software programming experience\n6 months+ experience with Cloud technology: GCP, AWS, or Azure\nSelf-starter that identifies/responds to priority shifts with minimal supervision\nUI development (e.g. HTML, JavaScript, Angular and Bootstrap)\nExperience with backend technologies such as JAVA/J2EE, SpringBoot, SOA and Microservices\nSource code control management systems (e.g. SVN/Git, Github) and build tools like Maven \u0026 Gradle.\nAgile environments (e.g. Scrum, XP)\nRelational databases (e.g. SQL Server, MySQL)\nAtlassian tooling (e.g. JIRA, Confluence, and Github)\nDeveloping with modern JDK (v1.7+)\nAutomated Testing: JUnit, Selenium, LoadRunner, SoapUI.",
        "word_count": 134
      },
      {
        "bullet_count": 0,
        "heading": "What could set you apart",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "An ability to demonstrate successful",
          "last_5_words": "defined expectations of systems availability."
        },
        "text": "An ability to demonstrate successful performance of our Success Profile skills, including:\nAgile Engineering Best Practices - Has basic knowledge of managing timely delivery of assigned engineering tasks and reporting status within agile ceremonies.\nEngineering Design - Has basic knowledge of design patterns and software engineering development lifecycle. Has basic knowledge of devops, SecOps and FinOps practices and levers that help to build effective, efficient and safe working software that meets business goals.\nEngineering Requirement Analysis - Has basic knowledge of decomposing business requirements into tactical software engineering task.\nIdea Creation - Has basic knowledge of business value creation through software engineering and continues to be curious about achieving the goals with more efficient ways.\nIndustry Knowledge - Has basic knowledge about latest trends within software engineering fields and how it applies to role and responsibilities tactical goals.\nSystems Thinking - Has basic knowledge of how systems integrate with others. Assists in identifying factors that achieve the defined expectations of systems availability.",
        "word_count": 164
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "a7b376ec-51ce-4870-bafe-d39125c7a090",
  "stage3_signals": {
    "alias_found": true,
    "alias_match_roles": [
      {
        "display_name": "Android Engineer",
        "matched_count": null,
        "role_id": 4,
        "score": 0.6923,
        "slug": "android-engineer",
        "total_count": null
      },
      {
        "display_name": "Backend Engineer",
        "matched_count": null,
        "role_id": 1,
        "score": 0.6923,
        "slug": "backend-engineer",
        "total_count": null
      },
      {
        "display_name": "AI Engineer",
        "matched_count": null,
        "role_id": 13,
        "score": 0.5556,
        "slug": "ai-engineer",
        "total_count": null
      },
      {
        "display_name": "ML Engineer",
        "matched_count": null,
        "role_id": 3,
        "score": 0.5294,
        "slug": "ml-engineer",
        "total_count": null
      },
      {
        "display_name": "Data Engineer",
        "matched_count": null,
        "role_id": 2,
        "score": 0.5263,
        "slug": "data-engineer",
        "total_count": null
      }
    ],
    "kra_match_roles": [
      {
        "display_name": "DevOps Engineer",
        "matched_count": null,
        "role_id": 10,
        "score": 0.6065,
        "slug": "devops-engineer",
        "total_count": null
      },
      {
        "display_name": "Frontend Engineer",
        "matched_count": null,
        "role_id": 7,
        "score": 0.5717,
        "slug": "frontend-engineer",
        "total_count": null
      },
      {
        "display_name": "Cloud Architect",
        "matched_count": null,
        "role_id": 9,
        "score": 0.5696,
        "slug": "cloud-architect",
        "total_count": null
      },
      {
        "display_name": "Full Stack Engineer",
        "matched_count": null,
        "role_id": 15,
        "score": 0.5356,
        "slug": "full-stack-engineer",
        "total_count": null
      },
      {
        "display_name": "Ios engineer",
        "matched_count": null,
        "role_id": 6,
        "score": 0.5263,
        "slug": "ios-engineer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "Backend Engineer",
        "matched_count": 10,
        "role_id": 1,
        "score": 0.2778,
        "slug": "backend-engineer",
        "total_count": 36
      },
      {
        "display_name": "Full Stack Engineer",
        "matched_count": 9,
        "role_id": 15,
        "score": 0.25,
        "slug": "full-stack-engineer",
        "total_count": 36
      },
      {
        "display_name": "DevOps Engineer",
        "matched_count": 8,
        "role_id": 10,
        "score": 0.2222,
        "slug": "devops-engineer",
        "total_count": 36
      },
      {
        "display_name": "ML Engineer",
        "matched_count": 5,
        "role_id": 3,
        "score": 0.1389,
        "slug": "ml-engineer",
        "total_count": 36
      },
      {
        "display_name": "Cloud Architect",
        "matched_count": 5,
        "role_id": 9,
        "score": 0.1389,
        "slug": "cloud-architect",
        "total_count": 36
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": false,
    "case": "A",
    "chosen_role": {
      "display_name": "Ios engineer",
      "matched_count": null,
      "role_id": 6,
      "score": 1.0,
      "slug": "ios-engineer",
      "total_count": null
    },
    "confidence": 0.5263,
    "llm2_fired": false,
    "llm2_reasoning": null,
    "queued": false,
    "reasoning": "Stage 1 title \u0027Ios engineer\u0027 (embedding match, sim 0.81); KRA agrees (0.53)"
  },
  "stage5_updates": {
    "centroid_n_after": 20,
    "centroid_updated": true,
    "collision_log_id": null,
    "new_kra_attached": null,
    "new_skills_attached": [
      {
        "is_primary": true,
        "queue_id": 1702,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Bootstrap",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1703,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "SOA",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1704,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "SVN",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1705,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "XP",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1706,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "JIRA",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1707,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Confluence",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1708,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "JDK",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1709,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "JUnit",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1710,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Selenium",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1711,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "LoadRunner",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1712,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "SoapUI",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1713,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Serverless Computing",
        "status": "pending"
      },
      {
        "is_primary": true,
        "queue_id": 1714,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "Infrastructure as Code",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 1715,
        "role_display_name": "Ios engineer",
        "role_slug": "ios-engineer",
        "skill_name": "SecOps",
        "status": "pending"
      }
    ],
    "queue_entry_id": null,
    "v3_pipeline_triggered": false,
    "v3_role_slug": null,
    "v3_run_id": null
  }
}
API 2 — extract-details
{
  "alias_matches": [
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 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": 405,
      "existing_alias_text": "GCP",
      "input_term": "GCP",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "GCP",
        "id": 186,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "gcp",
        "sub_category_id": 46,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 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": 407,
      "existing_alias_text": "Azure",
      "input_term": "Azure",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "Azure",
        "id": 188,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "azure",
        "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": 2627,
      "existing_alias_text": "HTML",
      "input_term": "HTML",
      "matched_canonical": {
        "category_id": 4,
        "display_name": "HTML",
        "id": 1657,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "STANDARD",
        "slug": "html",
        "sub_category_id": 1250,
        "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": 1067,
      "existing_alias_text": "Angular",
      "input_term": "Angular",
      "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": 2511,
      "existing_alias_text": "J2EE",
      "input_term": "J2EE",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "J2EE",
        "id": 1565,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "j2ee",
        "sub_category_id": 1172,
        "typical_lifespan": "SHORT_LIVED",
        "volatility": "DEPRECATED"
      },
      "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": 178,
      "existing_alias_text": "microservices",
      "input_term": "Microservices",
      "matched_canonical": {
        "category_id": 1,
        "display_name": "microservices",
        "id": 41,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "microservices",
        "sub_category_id": 1,
        "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": 541,
      "existing_alias_text": "GitHub",
      "input_term": "GitHub",
      "matched_canonical": {
        "category_id": 9,
        "display_name": "GitHub",
        "id": 280,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "github",
        "sub_category_id": 170,
        "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": 1360,
      "existing_alias_text": "Maven",
      "input_term": "Maven",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Maven",
        "id": 815,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "maven",
        "sub_category_id": 358,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1361,
      "existing_alias_text": "Gradle",
      "input_term": "Gradle",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Gradle",
        "id": 816,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "gradle",
        "sub_category_id": 649,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1851,
      "existing_alias_text": "Scrum",
      "input_term": "Scrum",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "Scrum",
        "id": 1215,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "scrum",
        "sub_category_id": 921,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 135,
      "existing_alias_text": "SQL Server",
      "input_term": "SQL Server",
      "matched_canonical": {
        "category_id": 3,
        "display_name": "SQL Server",
        "id": 18,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "sql-server",
        "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": 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": "TODO: REMOVE AFTER TESTING \u2014 alias DB write disabled",
      "alias_persisted": false,
      "existing_alias_id": 2191,
      "existing_alias_text": "JDK 7",
      "input_term": "JDK",
      "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": "embedding_alias"
    },
    {
      "alias_persist_skipped_reason": "TODO: REMOVE AFTER TESTING \u2014 alias DB write disabled",
      "alias_persisted": false,
      "existing_alias_id": 1345,
      "existing_alias_text": "Serverless Framework",
      "input_term": "Serverless Computing",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "Serverless Framework",
        "id": 800,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "serverless-framework",
        "sub_category_id": 145,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "embedding_alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1826,
      "existing_alias_text": "CI/CD",
      "input_term": "CI/CD",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "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": 2624,
      "existing_alias_text": "design patterns",
      "input_term": "Design Patterns",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "design patterns",
        "id": 1654,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "design-patterns",
        "sub_category_id": 1247,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1852,
      "existing_alias_text": "DevOps",
      "input_term": "DevOps",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "DevOps",
        "id": 1216,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "devops",
        "sub_category_id": 922,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1315,
      "existing_alias_text": "FinOps",
      "input_term": "FinOps",
      "matched_canonical": {
        "category_id": 8,
        "display_name": "FinOps",
        "id": 770,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "finops",
        "sub_category_id": 545,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "matched_via": "alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": "Android Engineer",
      "id": 4,
      "rationale": null,
      "role_archetype": null,
      "slug": "android-engineer",
      "source": "db"
    },
    {
      "display_name": "Backend Engineer",
      "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": "Full Stack Engineer",
      "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": "Cybersecurity Engineer",
      "id": 5,
      "rationale": null,
      "role_archetype": null,
      "slug": "cybersecurity-engineer",
      "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": "ML Ops Engineer",
      "id": 16,
      "rationale": null,
      "role_archetype": null,
      "slug": "ml-ops-engineer",
      "source": "db"
    },
    {
      "display_name": "AI Engineer",
      "id": 13,
      "rationale": null,
      "role_archetype": null,
      "slug": "ai-engineer",
      "source": "db"
    },
    {
      "display_name": "Cloud Architect",
      "id": 9,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-architect",
      "source": "db"
    },
    {
      "display_name": "Cloud Security Engineer",
      "id": 23,
      "rationale": null,
      "role_archetype": null,
      "slug": "cloud-security-engineer",
      "source": "db"
    },
    {
      "display_name": "Hybrid Mobile Developer",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "hybrid-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "Frontend Engineer",
      "id": 7,
      "rationale": null,
      "role_archetype": null,
      "slug": "frontend-engineer",
      "source": "db"
    },
    {
      "display_name": "Ios engineer",
      "id": 6,
      "rationale": null,
      "role_archetype": null,
      "slug": "ios-engineer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Full Stack Engineer",
    "id": 15,
    "rationale": "The primary skills listed encompass both front-end and back-end technologies, making Full Stack Engineer the most fitting title.",
    "role_archetype": null,
    "slug": "full-stack-engineer",
    "source": "db"
  },
  "dimensions": [
    {
      "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 Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "Java",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Full Stack Engineer",
          "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": "Cloud Platforms",
        "id": 20,
        "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "GCP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms for AI Deployment",
        "id": 211,
        "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
        "slug": "cloud-platforms-for-ai-deployment",
        "source": "db"
      },
      "input_skill": "GCP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AI Engineer",
          "id": 13,
          "rationale": null,
          "role_archetype": null,
          "slug": "ai-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Provider Platforms",
        "id": 131,
        "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
        "slug": "cloud-provider-platforms",
        "source": "db"
      },
      "input_skill": "GCP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Security Posture Tools",
        "id": 64,
        "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
        "slug": "cloud-security-posture-tools",
        "source": "db"
      },
      "input_skill": "GCP",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        },
        {
          "display_name": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "AWS",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "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": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms",
        "id": 20,
        "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
        "slug": "cloud-platforms",
        "source": "db"
      },
      "input_skill": "Azure",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Cybersecurity 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": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Platforms \u0026 Managed Services",
        "id": 221,
        "rationale": "Operates and integrates vendor-specific cloud compute, storage, and hosting services.",
        "slug": "cloud-platforms-managed-services",
        "source": "db"
      },
      "input_skill": "Azure",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "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": "Azure",
      "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": "Azure",
      "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": "Azure",
      "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": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "HTML",
      "llm_role": null,
      "roles_from_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": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "JavaScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "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": "Angular",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Full Stack Engineer",
          "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"
        }
      ]
    },
    {
      "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": "J2EE",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-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 Engineer",
          "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": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Microservices and Distributed Systems",
        "id": 9,
        "rationale": "Architectural patterns for decomposed backend systems and the operational concerns they introduce. Covers service boundaries, consistency tradeoffs, retries, circuit breakers, and distributed coordination.",
        "slug": "microservices-and-distributed-systems",
        "source": "db"
      },
      "input_skill": "Microservices",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "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": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "GitHub",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD for Machine Learning",
        "id": 56,
        "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
        "slug": "ci-cd-for-machine-learning",
        "source": "db"
      },
      "input_skill": "GitHub",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Build and Packaging Tooling",
        "id": 149,
        "rationale": "Tools and manifests used to compile, package, and assemble deployable artifacts. This is a core DevOps surface because release reliability depends on reproducible builds and consistent packaging across services and environments.",
        "slug": "build-and-packaging-tooling",
        "source": "db"
      },
      "input_skill": "Maven",
      "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": "Build and Packaging Tooling",
        "id": 149,
        "rationale": "Tools and manifests used to compile, package, and assemble deployable artifacts. This is a core DevOps surface because release reliability depends on reproducible builds and consistent packaging across services and environments.",
        "slug": "build-and-packaging-tooling",
        "source": "db"
      },
      "input_skill": "Gradle",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Build and Release Tooling",
        "id": 89,
        "rationale": "Tooling used to compile, sign, package, and automate iOS app builds. iOS engineers rely on this stack to produce reproducible release artifacts and manage build-time configuration.",
        "slug": "build-and-release-tooling",
        "source": "db"
      },
      "input_skill": "Gradle",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ios engineer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Scrum",
      "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": "SQL Server",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Relational Data Modeling",
        "id": 216,
        "rationale": "Schema design and query-aware persistence for product features. Full stack engineers use this to shape tables, relationships, migrations, and transactional behavior that support application flows.",
        "slug": "relational-data-modeling",
        "source": "db"
      },
      "input_skill": "MySQL",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Full Stack Engineer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "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": "Backend Engineer",
          "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": "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": "JDK",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Engineer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "JDK",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Engineer",
          "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": "Full Stack Engineer",
          "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": "JDK",
      "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": "Infrastructure as Code",
        "id": 132,
        "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
        "slug": "infrastructure-as-code",
        "source": "db"
      },
      "input_skill": "Serverless Computing",
      "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": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD for Machine Learning",
        "id": 56,
        "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
        "slug": "ci-cd-for-machine-learning",
        "source": "db"
      },
      "input_skill": "CI/CD",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        }
      ]
    },
    {
      "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": "Design Patterns",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CI/CD Pipeline Platforms",
        "id": 150,
        "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
        "slug": "ci-cd-pipeline-platforms",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Deployment and Release Patterns",
        "id": 140,
        "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
        "slug": "deployment-and-release-patterns",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Infrastructure as Code",
        "id": 132,
        "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
        "slug": "infrastructure-as-code",
        "source": "db"
      },
      "input_skill": "DevOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Architect",
          "id": 9,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-architect",
          "source": "db"
        },
        {
          "display_name": "DevOps Engineer",
          "id": 10,
          "rationale": null,
          "role_archetype": null,
          "slug": "devops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Cost and FinOps",
        "id": 142,
        "rationale": "Cost governance and optimization practices used to align cloud consumption with budgets and business value. Cloud Architects need this to shape service selection, environment sizing, and platform standards.",
        "slug": "cloud-cost-and-finops",
        "source": "db"
      },
      "input_skill": "FinOps",
      "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": "Bootstrap",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Systems Programming",
        "id": 166,
        "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
        "slug": "d_init_02",
        "source": "db"
      },
      "input_skill": "Bootstrap",
      "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": "SOA",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Model and Data Versioning",
        "id": 48,
        "rationale": "Versioning systems for datasets, features, and model artifacts at the storage layer. This enables reproducible training, rollback, lineage of artifacts, and controlled promotion of model assets.",
        "slug": "model-and-data-versioning",
        "source": "db"
      },
      "input_skill": "SVN",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Model and Data Versioning",
        "id": 48,
        "rationale": "Versioning systems for datasets, features, and model artifacts at the storage layer. This enables reproducible training, rollback, lineage of artifacts, and controlled promotion of model assets.",
        "slug": "model-and-data-versioning",
        "source": "db"
      },
      "input_skill": "SVN",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "ML Engineer",
          "id": 3,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-engineer",
          "source": "db"
        },
        {
          "display_name": "ML Ops Engineer",
          "id": 16,
          "rationale": null,
          "role_archetype": null,
          "slug": "ml-ops-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "XP",
      "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": "JIRA",
      "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": "Confluence",
      "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": "JUnit",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frontend Testing and E2E Automation",
        "id": 122,
        "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
        "slug": "frontend-testing-and-e2e-automation",
        "source": "db"
      },
      "input_skill": "Selenium",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Selenium",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frontend Testing and E2E Automation",
        "id": 122,
        "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
        "slug": "frontend-testing-and-e2e-automation",
        "source": "db"
      },
      "input_skill": "Selenium",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "LoadRunner",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frontend Testing and E2E Automation",
        "id": 122,
        "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
        "slug": "frontend-testing-and-e2e-automation",
        "source": "db"
      },
      "input_skill": "SoapUI",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Frontend Testing and E2E Automation",
        "id": 122,
        "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
        "slug": "frontend-testing-and-e2e-automation",
        "source": "db"
      },
      "input_skill": "SoapUI",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Engineer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Infrastructure as Code",
        "id": 132,
        "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
        "slug": "infrastructure-as-code",
        "source": "db"
      },
      "input_skill": "Infrastructure as Code",
      "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": "Environment Provisioning and Parity",
        "id": 157,
        "rationale": "Creating and maintaining consistent dev, test, staging, and production environments. This cluster is coherent because delivery failures often come from environment drift, missing dependencies, or inconsistent configuration.",
        "slug": "environment-provisioning-and-parity",
        "source": "db"
      },
      "input_skill": "Infrastructure as Code",
      "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": "Security Architecture and Hardening",
        "id": 75,
        "rationale": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
        "slug": "security-architecture-and-hardening",
        "source": "db"
      },
      "input_skill": "Infrastructure as Code",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Environment Provisioning and Parity",
        "id": 157,
        "rationale": "Creating and maintaining consistent dev, test, staging, and production environments. This cluster is coherent because delivery failures often come from environment drift, missing dependencies, or inconsistent configuration.",
        "slug": "environment-provisioning-and-parity",
        "source": "db"
      },
      "input_skill": "Infrastructure as Code",
      "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": "Security Architecture and Hardening",
        "id": 75,
        "rationale": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
        "slug": "security-architecture-and-hardening",
        "source": "db"
      },
      "input_skill": "Infrastructure as Code",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Security Architecture and Hardening",
        "id": 75,
        "rationale": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
        "slug": "security-architecture-and-hardening",
        "source": "db"
      },
      "input_skill": "SecOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Configuration Review",
        "id": 244,
        "rationale": "Review practices for evaluating cloud resources against security baselines and approved control requirements. This includes reading configurations, identifying drift, and documenting remediation guidance for owning teams.",
        "slug": "cloud-configuration-review",
        "source": "db"
      },
      "input_skill": "SecOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cloud Configuration Review",
        "id": 244,
        "rationale": "Review practices for evaluating cloud resources against security baselines and approved control requirements. This includes reading configurations, identifying drift, and documenting remediation guidance for owning teams.",
        "slug": "cloud-configuration-review",
        "source": "db"
      },
      "input_skill": "SecOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cloud Security Engineer",
          "id": 23,
          "rationale": null,
          "role_archetype": null,
          "slug": "cloud-security-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Security Architecture and Hardening",
        "id": 75,
        "rationale": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
        "slug": "security-architecture-and-hardening",
        "source": "db"
      },
      "input_skill": "SecOps",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Cybersecurity Engineer",
          "id": 5,
          "rationale": null,
          "role_archetype": null,
          "slug": "cybersecurity-engineer",
          "source": "db"
        }
      ]
    }
  ],
  "input_final_skills": [
    "Java",
    "GCP",
    "AWS",
    "Azure",
    "HTML",
    "JavaScript",
    "Angular",
    "Bootstrap",
    "J2EE",
    "Spring Boot",
    "SOA",
    "Microservices",
    "SVN",
    "Git",
    "GitHub",
    "Maven",
    "Gradle",
    "Scrum",
    "XP",
    "SQL Server",
    "MySQL",
    "JIRA",
    "Confluence",
    "JDK",
    "JUnit",
    "Selenium",
    "LoadRunner",
    "SoapUI",
    "Serverless Computing",
    "CI/CD",
    "Infrastructure as Code",
    "Agile",
    "Design Patterns",
    "DevOps",
    "SecOps",
    "FinOps"
  ],
  "input_llm_skills": [
    "Java",
    "GCP",
    "AWS",
    "Azure",
    "HTML",
    "JavaScript",
    "Angular",
    "Bootstrap",
    "J2EE",
    "Spring Boot",
    "SOA",
    "Microservices",
    "SVN",
    "Git",
    "GitHub",
    "Maven",
    "Gradle",
    "Scrum",
    "XP",
    "SQL Server",
    "MySQL",
    "JIRA",
    "Confluence",
    "JDK",
    "JUnit",
    "Selenium",
    "LoadRunner",
    "SoapUI",
    "Serverless Computing",
    "CI/CD",
    "Infrastructure as Code",
    "Agile",
    "Design Patterns",
    "DevOps",
    "SecOps",
    "FinOps"
  ],
  "new_aliases_persisted": 0,
  "run_id": "a7b376ec-51ce-4870-bafe-d39125c7a090",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "Java",
          "alias_type": "CANONICAL",
          "id": 1,
          "is_primary": true,
          "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": "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-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": "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 Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "Java",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Full Stack Engineer",
              "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": "GCP",
          "alias_type": "CANONICAL",
          "id": 405,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "GCP",
        "id": 186,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "gcp",
        "sub_category_id": 46,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms",
            "id": 20,
            "rationale": "Underlying cloud providers that host the managed services or infrastructure used by the role, such as AWS, Azure, and GCP.",
            "slug": "cloud-platforms",
            "source": "db"
          },
          "input_skill": "GCP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms for AI Deployment",
            "id": 211,
            "rationale": "Major cloud services that provide infrastructure and managed services for AI workloads.",
            "slug": "cloud-platforms-for-ai-deployment",
            "source": "db"
          },
          "input_skill": "GCP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AI Engineer",
              "id": 13,
              "rationale": null,
              "role_archetype": null,
              "slug": "ai-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Provider Platforms",
            "id": 131,
            "rationale": "Major cloud platforms and their core service ecosystems used to design target-state architectures, choose deployment boundaries, and evaluate managed capabilities. This is the primary substrate for cloud architecture decisions.",
            "slug": "cloud-provider-platforms",
            "source": "db"
          },
          "input_skill": "GCP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Security Posture Tools",
            "id": 64,
            "rationale": "Cloud-native security platforms used to assess misconfiguration, workload exposure, and cloud control coverage. This dimension includes the major CNAPP/CSPM/CWPP vendors and cloud security services the role reviews and tunes.",
            "slug": "cloud-security-posture-tools",
            "source": "db"
          },
          "input_skill": "GCP",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            },
            {
              "display_name": "Cybersecurity Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "GCP",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "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": "Backend Engineer",
              "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": "Cybersecurity 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": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "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": "Cybersecurity 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": "Azure",
          "alias_type": "CANONICAL",
          "id": 407,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "Azure",
        "id": 188,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "azure",
        "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": "Azure",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Cybersecurity 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": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Platforms \u0026 Managed Services",
            "id": 221,
            "rationale": "Operates and integrates vendor-specific cloud compute, storage, and hosting services.",
            "slug": "cloud-platforms-managed-services",
            "source": "db"
          },
          "input_skill": "Azure",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "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": "Azure",
          "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": "Azure",
          "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": "Azure",
          "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": "Cybersecurity Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Azure",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "HTML",
          "alias_type": "CANONICAL",
          "id": 2627,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 4,
        "display_name": "HTML",
        "id": 1657,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "STANDARD",
        "slug": "html",
        "sub_category_id": 1250,
        "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": "HTML",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "HTML",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "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": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "JavaScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "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": "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 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 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 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": "ng",
          "alias_type": "VERSION",
          "id": 2088,
          "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": "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": "Angular",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Full Stack Engineer",
              "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"
            }
          ]
        }
      ],
      "input_skill": "Angular",
      "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": [
        {
          "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": "Bootstrap",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Systems Programming",
            "id": 166,
            "rationale": "Systems programming covers low-level software development where performance, memory safety, and direct control over resources matter. Rust fits here because it is commonly used for OS-adjacent services, infrastructure components, and other performance-sensitive systems code.",
            "slug": "d_init_02",
            "source": "db"
          },
          "input_skill": "Bootstrap",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Bootstrap",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Framework",
          "skill_nature": "FRAMEWORK",
          "sub_category": "css_framework",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "SEPARATE_ENTITY",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cBootstrap\u201d in JDs typically refers to the Bootstrap CSS framework; other meanings are uncommon in this context."
          },
          "context_keywords": {
            "context_keywords": [
              "responsive design",
              "grid system",
              "Sass",
              "jQuery",
              "components",
              "modals",
              "navigation",
              "utilities",
              "customization",
              "themes",
              "Bootstrap 5",
              "flexbox",
              "card layout",
              "form controls",
              "media queries"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Bootstrap remains widely listed in job descriptions for responsive UI work and is still heavily used in existing web stacks; GitHub activity and CDN usage show sustained demand, not a sunset replacement."
          },
          "skill_id": "bootstrap",
          "vendor_license": {
            "confidence": 0.95,
            "license": "mit",
            "vendor": "Twitter",
            "year_introduced": 2011
          },
          "versioning": {
            "current_version": "5",
            "version_aliases": {
              "bootstrap 5": "5",
              "bootstrap 5.x": "5",
              "bootstrap v5": "5",
              "bootstrap5": "5",
              "bs5": "5"
            },
            "versioned": true
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Initial setup and scaffolding for browser-based applications, including project startup, app wiring, and first-screen composition. Bootstrap belongs here when it refers to the UI framework or starter structure used to launch a frontend app.",
            "exemplar_skills": [
              "Bootstrap",
              "frontend app scaffolding",
              "project initialization",
              "entry point setup",
              "routing bootstrap",
              "state provider wiring"
            ],
            "in_scope": "Bootstrap, app scaffolding, starter templates, project initialization, frontend entry points, component tree setup, routing bootstrap, state provider wiring",
            "name": "Frontend Application Bootstrap",
            "out_of_scope": "CSS utility classes, responsive styling, design systems, which belong to UI styling and component design; server-side app startup, which belongs to web application frameworks; build tooling and package management, which belong to build and release tooling",
            "overlap_flags": [
              {
                "reason": "Bootstrap can overlap with UI framework setup when used to initialize component-based frontend apps.",
                "with_dim_id": "ui-frameworks-and-rendering",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer, Hybrid Mobile Developer"
              },
              {
                "reason": "If Bootstrap refers to app startup in a meta-framework, the boundary can blur with SSR and routing initialization.",
                "with_dim_id": "meta-frameworks-ssr",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "The Bootstrap front-end framework for building responsive layouts, reusable UI components, and utility-driven styling. This dimension fits when Bootstrap means the popular CSS/JS framework rather than generic startup or initialization.",
            "exemplar_skills": [
              "Bootstrap",
              "Bootstrap CSS",
              "Bootstrap grid system",
              "Bootstrap components",
              "Bootstrap utilities",
              "responsive layout classes",
              "navbars",
              "modals"
            ],
            "in_scope": "Bootstrap, Bootstrap CSS, Bootstrap grid system, Bootstrap components, Bootstrap utilities, responsive layout classes, modals, navbars, forms, alerts",
            "name": "Bootstrap CSS Framework",
            "out_of_scope": "Custom design tokens and visual systems, which belong to UI design systems; JavaScript application bootstrapping, which belongs to frontend application bootstrap; server-side rendering and routing, which belong to meta-frameworks and SSR",
            "overlap_flags": [
              {
                "reason": "Bootstrap is often used alongside UI component frameworks and can be mistaken for general frontend rendering skills.",
                "with_dim_id": "ui-frameworks-and-rendering",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer, Hybrid Mobile Developer"
              }
            ],
            "tentative_id": "d_init_02"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Bootstrap",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "d_init_02"
          ],
          "skill_id": "bootstrap"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "frontend"
          ],
          "related_to": [
            "responsive-web-development",
            "cross-browser-compatibility",
            "html",
            "authentication",
            "widget-testing",
            "a-b-testing",
            "logging",
            "analytics"
          ],
          "requires": [],
          "skill_id": "bootstrap",
          "suppress_on_match": []
        },
        "skill_id": "bootstrap",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "Bootstrap",
          "reasoning": "Bootstrap is a frontend framework because developers build applications and UIs with it rather than merely using it as standalone software.",
          "skill_id": "bootstrap",
          "subtype": "css_framework",
          "type": "Framework"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "J2EE",
          "alias_type": "CANONICAL",
          "id": 2511,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "J2EE",
        "id": 1565,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "j2ee",
        "sub_category_id": 1172,
        "typical_lifespan": "SHORT_LIVED",
        "volatility": "DEPRECATED"
      },
      "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": "J2EE",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "J2EE",
      "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"
        }
      ],
      "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 Engineer",
              "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": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "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": [],
      "canonical": null,
      "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": "SOA",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "SOA",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Architecture",
          "skill_nature": "PATTERN",
          "sub_category": "service_oriented_architecture",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": true,
            "confused_with": [
              "microservices",
              "event_driven_architecture"
            ],
            "reasoning": "SOA is often mentioned alongside or confused with other service-based architectures like microservices or event-driven architecture in JDs."
          },
          "context_keywords": {
            "context_keywords": [
              "microservices",
              "RESTful services",
              "SOAP",
              "WSDL",
              "ESB",
              "API gateway",
              "service registry",
              "message broker",
              "service orchestration",
              "service composition",
              "loose coupling",
              "interoperability",
              "scalability",
              "service contract",
              "business process management"
            ]
          },
          "maturity": {
            "confidence": 0.78,
            "maturity": "well_known",
            "reasoning": "SOA remains a common architecture term in enterprise JDs and vendor docs, though often framed as legacy/transition toward microservices rather than a new niche skill."
          },
          "skill_id": "soa",
          "vendor_license": {
            "confidence": 0.9,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Architectural style for designing systems as loosely coupled services with explicit contracts and composable boundaries. SOA belongs here because it refers to the service-based decomposition and integration approach rather than a specific framework or platform.",
            "exemplar_skills": [
              "SOA",
              "service-oriented architecture",
              "service decomposition",
              "service contracts",
              "loose coupling",
              "service composition"
            ],
            "in_scope": "SOA, service-oriented architecture, service decomposition, service contracts, loose coupling, service composition, enterprise service bus patterns, service interfaces, service boundaries, integration services",
            "name": "Service-Oriented Architecture",
            "out_of_scope": "REST API design, microservices implementation details, message broker operations, cloud deployment tooling, UI architecture, database schema design",
            "overlap_flags": [
              {
                "reason": "Both can involve building services, but this dimension is about the architectural style while web frameworks cover implementation mechanics.",
                "with_dim_id": "web-application-frameworks",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Full Stack Engineer"
              },
              {
                "reason": "SOA often uses messaging for integration, but messaging platforms are transport infrastructure rather than the architecture itself.",
                "with_dim_id": "messaging-and-event-streaming",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Data Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "SOA",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "soa"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "api",
            "api-security",
            "authentication",
            "waf",
            "logging",
            "sdlc",
            "j2ee",
            "websphere"
          ],
          "requires": [],
          "skill_id": "soa",
          "suppress_on_match": []
        },
        "skill_id": "soa",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.98,
          "name": "SOA",
          "reasoning": "SOA is a system-shape pattern for structuring applications as services, so by the Architecture vs Concept rule it is an Architecture.",
          "skill_id": "soa",
          "subtype": "service_oriented_architecture",
          "type": "Architecture"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "microservices",
          "alias_type": "CANONICAL",
          "id": 178,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 1,
        "display_name": "microservices",
        "id": 41,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PATTERN",
        "slug": "microservices",
        "sub_category_id": 1,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Microservices and Distributed Systems",
            "id": 9,
            "rationale": "Architectural patterns for decomposed backend systems and the operational concerns they introduce. Covers service boundaries, consistency tradeoffs, retries, circuit breakers, and distributed coordination.",
            "slug": "microservices-and-distributed-systems",
            "source": "db"
          },
          "input_skill": "Microservices",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Microservices",
      "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": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Model and Data Versioning",
            "id": 48,
            "rationale": "Versioning systems for datasets, features, and model artifacts at the storage layer. This enables reproducible training, rollback, lineage of artifacts, and controlled promotion of model assets.",
            "slug": "model-and-data-versioning",
            "source": "db"
          },
          "input_skill": "SVN",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Model and Data Versioning",
            "id": 48,
            "rationale": "Versioning systems for datasets, features, and model artifacts at the storage layer. This enables reproducible training, rollback, lineage of artifacts, and controlled promotion of model assets.",
            "slug": "model-and-data-versioning",
            "source": "db"
          },
          "input_skill": "SVN",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            },
            {
              "display_name": "ML Ops Engineer",
              "id": 16,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-ops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "SVN",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Tool",
          "skill_nature": "TOOL",
          "sub_category": "version_control_tool",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cSVN\u201d most commonly refers to Subversion, a version control tool; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "repository",
              "commit",
              "checkout",
              "merge",
              "branching",
              "trunk",
              "revision",
              "conflict resolution",
              "diff",
              "update",
              "SVN client",
              "subversion",
              "tags",
              "working copy",
              "remote repository"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "niche",
            "reasoning": "SVN still appears in some legacy enterprise JDs, but Git dominates hiring pipelines and new repos; GitHub/GitLab market share and repo activity signal far higher demand for Git-based workflows."
          },
          "skill_id": "svn",
          "vendor_license": {
            "confidence": 0.95,
            "license": "apache_2",
            "vendor": "Apache Software Foundation",
            "year_introduced": 2000
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "model-and-data-versioning",
            "a_name": "Model and Data Versioning",
            "a_role": "__skill_focal__",
            "b_dim_id": "model-and-data-versioning",
            "b_name": "Model and Data Versioning",
            "b_role": "ML Engineer",
            "pair_kind": "cross_role",
            "reasoning": "Dim A is SVN/Subversion source control: its description names SVN as a source control system, and exemplars include revision control, branching and merging, tags and releases, and check-in/check-out. Dim B is ML storage-layer versioning for datasets, features, and model artifacts, focused on reproducible training, rollback, lineage, and controlled promotion. A senior SVN practitioner would not naturally be a senior ML artifact/versioning practitioner; the toolchains and daily work differ. career-track: no, because source-control administration and ML artifact/versioning are distinct specialties.",
            "similarity": 0.7630709949960531
          }
        ],
        "locked_dimensions": [
          {
            "description": "Version control practices for datasets, artifacts, and related project assets that need reproducibility and rollback. SVN fits here as a source control system used to track changes, manage revisions, and coordinate shared work on code or assets.",
            "exemplar_skills": [
              "SVN",
              "Subversion",
              "revision control",
              "branching and merging",
              "tags and releases",
              "check-in/check-out"
            ],
            "in_scope": "SVN, Subversion repositories, revision history, branching and merging, tags and releases, check-in/check-out workflows, code and asset version control, reproducible change tracking",
            "name": "Model and Data Versioning",
            "out_of_scope": "Git workflows and distributed version control, CI/CD pipeline automation, deployment orchestration, binary artifact repositories, dataset lineage tooling that is not source control",
            "overlap_flags": [
              {
                "reason": "SVN often feeds build and release automation, but the source control system itself belongs in versioning rather than pipeline orchestration.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              }
            ],
            "tentative_id": "model-and-data-versioning"
          },
          {
            "description": "Versioning systems for datasets, features, and model artifacts at the storage layer. This enables reproducible training, rollback, lineage of artifacts, and controlled promotion of model assets.",
            "exemplar_skills": [
              "Model and Data Versioning"
            ],
            "in_scope": "Skills, tools, and practices that belong under Model and Data Versioning for the target role, including items implied by the dimension rationale.",
            "name": "Model and Data Versioning",
            "out_of_scope": "Adjacent clusters explicitly not owned by Model and Data Versioning, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "model-and-data-versioning"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "SVN",
          "placement_confidence": 0.92,
          "primary_dimension": "model-and-data-versioning",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "svn"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "sync",
            "sdlc",
            "go",
            "c",
            "spring",
            "xml",
            "vpn",
            "ztna"
          ],
          "requires": [],
          "skill_id": "svn",
          "suppress_on_match": []
        },
        "skill_id": "svn",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "SVN",
          "reasoning": "SVN is software users run to manage source control locally or against a server, so by the Tool vs Framework rule it is a Tool rather than a Framework or Platform.",
          "skill_id": "svn",
          "subtype": "version_control_tool",
          "type": "Tool"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "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": [
        {
          "alias_text": "GitHub",
          "alias_type": "CANONICAL",
          "id": 541,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 9,
        "display_name": "GitHub",
        "id": 280,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PLATFORM",
        "slug": "github",
        "sub_category_id": 170,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "GitHub",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD for Machine Learning",
            "id": 56,
            "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
            "slug": "ci-cd-for-machine-learning",
            "source": "db"
          },
          "input_skill": "GitHub",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "GitHub",
      "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": "Maven",
          "alias_type": "CANONICAL",
          "id": 1360,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Maven",
        "id": 815,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "maven",
        "sub_category_id": 358,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Build and Packaging Tooling",
            "id": 149,
            "rationale": "Tools and manifests used to compile, package, and assemble deployable artifacts. This is a core DevOps surface because release reliability depends on reproducible builds and consistent packaging across services and environments.",
            "slug": "build-and-packaging-tooling",
            "source": "db"
          },
          "input_skill": "Maven",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Maven",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Gradle",
          "alias_type": "CANONICAL",
          "id": 1361,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Gradle",
        "id": 816,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "gradle",
        "sub_category_id": 649,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Build and Packaging Tooling",
            "id": 149,
            "rationale": "Tools and manifests used to compile, package, and assemble deployable artifacts. This is a core DevOps surface because release reliability depends on reproducible builds and consistent packaging across services and environments.",
            "slug": "build-and-packaging-tooling",
            "source": "db"
          },
          "input_skill": "Gradle",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Build and Release Tooling",
            "id": 89,
            "rationale": "Tooling used to compile, sign, package, and automate iOS app builds. iOS engineers rely on this stack to produce reproducible release artifacts and manage build-time configuration.",
            "slug": "build-and-release-tooling",
            "source": "db"
          },
          "input_skill": "Gradle",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ios engineer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Gradle",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Scrum",
          "alias_type": "CANONICAL",
          "id": 1851,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Scrum",
        "id": 1215,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "scrum",
        "sub_category_id": 921,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Scrum",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Scrum",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "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": "XP",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "XP",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodology",
          "skill_nature": "METHODOLOGY",
          "sub_category": "extreme_programming",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": true,
            "confused_with": [
              "xps",
              "experience_points"
            ],
            "reasoning": "\u201cXP\u201d is commonly used for Experience Points or XPS (XML Paper Specification), not just Extreme Programming."
          },
          "context_keywords": {
            "context_keywords": [
              "pair programming",
              "test-driven development",
              "continuous integration",
              "refactoring",
              "user stories",
              "agile practices",
              "sprint planning",
              "collaborative coding",
              "feedback loops",
              "release planning",
              "code reviews",
              "collective code ownership",
              "simple design",
              "sustainable pace",
              "customer involvement"
            ]
          },
          "maturity": {
            "confidence": 0.82,
            "maturity": "niche",
            "reasoning": "XP appears in some agile/JD listings, but far less often than Scrum/Kanban; market demand is limited and usually folded into broader Agile experience rather than requested standalone."
          },
          "skill_id": "xp",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Software development practices associated with XP, emphasizing rapid feedback, close collaboration, and disciplined engineering habits. This skill belongs here because XP is a named methodology centered on how teams build software day to day.",
            "exemplar_skills": [
              "XP",
              "Extreme Programming",
              "pair programming",
              "test-driven development",
              "continuous integration",
              "refactoring",
              "collective code ownership"
            ],
            "in_scope": "XP, pair programming, test-driven development, continuous integration, refactoring, collective code ownership, simple design, small releases, customer collaboration",
            "name": "Extreme Programming Practices",
            "out_of_scope": "Agile project management ceremonies, product roadmap planning, release orchestration, cloud infrastructure provisioning, UI component design",
            "overlap_flags": [
              {
                "reason": "XP commonly encourages continuous integration, but the platform/tooling dimension owns the implementation details of CI systems.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              },
              {
                "reason": "XP often uses automated tests heavily, but the testing dimension owns specific test frameworks and browser automation.",
                "with_dim_id": "frontend-testing-and-e2e-automation",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "XP",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "xp"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "agile",
            "scrum",
            "kanban",
            "tdd",
            "refactoring",
            "pair-programming",
            "continuous-integration",
            "continuous-delivery"
          ],
          "requires": [],
          "skill_id": "xp",
          "suppress_on_match": []
        },
        "skill_id": "xp",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.98,
          "name": "XP",
          "reasoning": "XP refers to Extreme Programming, which is a way of working and therefore fits the Concept vs Methodology rule as a Methodology.",
          "skill_id": "xp",
          "subtype": "extreme_programming",
          "type": "Methodology"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "SQL Server",
          "alias_type": "CANONICAL",
          "id": 135,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 2000",
          "alias_type": "VERSION",
          "id": 138,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 2005",
          "alias_type": "VERSION",
          "id": 139,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 2008",
          "alias_type": "VERSION",
          "id": 140,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 2012",
          "alias_type": "VERSION",
          "id": 141,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 2014",
          "alias_type": "VERSION",
          "id": 142,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 2016",
          "alias_type": "VERSION",
          "id": 143,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 2017",
          "alias_type": "VERSION",
          "id": 144,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 2019",
          "alias_type": "VERSION",
          "id": 145,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 2022",
          "alias_type": "VERSION",
          "id": 146,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 6.5",
          "alias_type": "VERSION",
          "id": 136,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "SQL Server 7.0",
          "alias_type": "VERSION",
          "id": 137,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "SQL Server",
        "id": 18,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "sql-server",
        "sub_category_id": 29,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "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": "SQL Server",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "SQL Server",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "MySQL",
          "alias_type": "CANONICAL",
          "id": 134,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 3,
        "display_name": "MySQL",
        "id": 17,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "mysql",
        "sub_category_id": 29,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Relational Data Modeling",
            "id": 216,
            "rationale": "Schema design and query-aware persistence for product features. Full stack engineers use this to shape tables, relationships, migrations, and transactional behavior that support application flows.",
            "slug": "relational-data-modeling",
            "source": "db"
          },
          "input_skill": "MySQL",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Full Stack Engineer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "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": "Backend Engineer",
              "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": "MySQL",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "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": "JIRA",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "JIRA",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Tool",
          "skill_nature": "TOOL",
          "sub_category": "issue_tracking_tool",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "JIRA is a specific issue-tracking tool name; typical JDs won\u2019t confuse it with other distinct skills in the catalog."
          },
          "context_keywords": {
            "context_keywords": [
              "Agile",
              "Scrum",
              "Kanban",
              "backlog",
              "sprint",
              "issue tracking",
              "workflow",
              "epics",
              "user stories",
              "burndown",
              "roadmap",
              "release planning",
              "custom fields",
              "JQL",
              "dashboard"
            ]
          },
          "maturity": {
            "confidence": 0.97,
            "maturity": "well_known",
            "reasoning": "JIRA appears in a large share of software job descriptions for issue tracking and agile workflows, and Atlassian continues active product support with broad enterprise adoption."
          },
          "skill_id": "jira",
          "vendor_license": {
            "confidence": 0.95,
            "license": "other_open",
            "vendor": "Atlassian",
            "year_introduced": 2002
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Tools and practices for tracking tasks, bugs, epics, workflows, and team execution across a project lifecycle. JIRA belongs here because it is commonly used to create, prioritize, assign, and monitor work items.",
            "exemplar_skills": [
              "JIRA",
              "issue tracking",
              "backlog grooming",
              "sprint board management",
              "workflow automation",
              "ticket triage"
            ],
            "in_scope": "JIRA, issue creation and triage, epics and stories, task assignment, workflow states, sprint boards, backlog grooming, status tracking, workflow automation, ticket linking",
            "name": "Work Tracking and Issue Management",
            "out_of_scope": "Source control systems like Git and GitHub, CI/CD pipeline execution, incident response coordination, these belong to code management, delivery automation, or operations dimensions",
            "overlap_flags": [
              {
                "reason": "JIRA often integrates with delivery pipelines, but the core skill is work tracking rather than build/deploy automation.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              },
              {
                "reason": "JIRA can support incident tickets and coordination, but incident handling itself is a separate operational discipline.",
                "with_dim_id": "incident-response-and-coordination",
                "with_dim_name": null,
                "with_role": "Cloud Security Engineer, Cybersecurity Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "JIRA",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "jira"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "risk-register",
            "exception-review",
            "logging",
            "metrics",
            "site-reliability-engineering",
            "evaluation",
            "evaluation-frameworks",
            "api-integration"
          ],
          "requires": [],
          "skill_id": "jira",
          "suppress_on_match": []
        },
        "skill_id": "jira",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.98,
          "name": "JIRA",
          "reasoning": "JIRA is software you operate as a user for issue tracking and project management, so by the Tool vs Framework rule it is a Tool rather than a platform or framework.",
          "skill_id": "jira",
          "subtype": "issue_tracking_tool",
          "type": "Tool"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "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": "Confluence",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Confluence",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Platform",
          "skill_nature": "PLATFORM",
          "sub_category": "wiki_collaboration_platform",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cConfluence\u201d is a specific wiki/collaboration platform name; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "Atlassian",
              "documentation",
              "collaboration",
              "knowledge base",
              "team spaces",
              "page templates",
              "macro",
              "version control",
              "permissions",
              "integrations",
              "project management",
              "workflow",
              "content organization",
              "user management",
              "cloud hosting"
            ]
          },
          "maturity": {
            "confidence": 0.93,
            "maturity": "well_known",
            "reasoning": "Common in enterprise JDs for documentation/knowledge management; Atlassian reports broad adoption across teams, and it remains a standard collaboration platform rather than a niche tool."
          },
          "skill_id": "confluence",
          "vendor_license": {
            "confidence": 0.9,
            "license": "unknown",
            "vendor": "Atlassian",
            "year_introduced": 2004
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Tools and practices for creating, organizing, and sharing team knowledge, project docs, and operational runbooks. Confluence belongs here because it is commonly used as a collaborative documentation workspace rather than a coding or infrastructure tool.",
            "exemplar_skills": [
              "Confluence",
              "wiki authoring",
              "knowledge base management",
              "runbook documentation",
              "technical documentation",
              "documentation templates"
            ],
            "in_scope": "Confluence, wiki pages, team documentation, runbooks, meeting notes, decision logs, project specs, knowledge bases, page templates, documentation spaces",
            "name": "Documentation and Knowledge Management",
            "out_of_scope": "Source code repositories, issue tracking workflows, CI/CD automation, observability dashboards, security controls, which belong to engineering delivery, operations, or security dimensions",
            "overlap_flags": [
              {
                "reason": "Confluence is often linked from delivery workflows, but it is not itself a pipeline automation platform.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              },
              {
                "reason": "Operational runbooks may live in Confluence, yet the dimension is about documentation, not monitoring or incident tooling.",
                "with_dim_id": "observability-and-operations",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Confluence",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "confluence"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "sync",
            "cloud",
            "observability",
            "api",
            "xml",
            "eclipse",
            "spring",
            "tomcat"
          ],
          "requires": [],
          "skill_id": "confluence",
          "suppress_on_match": []
        },
        "skill_id": "confluence",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "Confluence",
          "reasoning": "By the Vendor SaaS rule, Confluence is a hosted multi-tenant commercial SaaS product consumed via Atlassian\u0027s service, so it is a Platform rather than a Tool or Framework.",
          "skill_id": "confluence",
          "subtype": "wiki_collaboration_platform",
          "type": "Platform"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Java",
          "alias_type": "CANONICAL",
          "id": 1,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "JDK 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": "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-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": "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": "JDK",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Engineer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "JDK",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Engineer",
              "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": "Full Stack Engineer",
              "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": "JDK",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Data Engineer",
              "id": 2,
              "rationale": null,
              "role_archetype": null,
              "slug": "data-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "JDK",
      "matched_via": "embedding_alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "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": "JUnit",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "JUnit",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Framework",
          "skill_nature": "FRAMEWORK",
          "sub_category": "testing_framework",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "SEPARATE_ENTITY",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "JUnit is a specific Java testing framework; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "Mockito",
              "TestNG",
              "JUnit 5",
              "assertions",
              "mocks",
              "integration testing",
              "unit tests",
              "annotations",
              "TDD",
              "code coverage",
              "JUnit 4",
              "parameterized tests",
              "setup methods",
              "test suites",
              "exception testing"
            ]
          },
          "maturity": {
            "confidence": 0.97,
            "maturity": "well_known",
            "reasoning": "JUnit is a standard Java testing framework and appears in many job descriptions for backend and QA roles; it remains a common hiring-pipeline staple alongside Maven/Gradle and CI."
          },
          "skill_id": "junit",
          "vendor_license": {
            "confidence": 0.9,
            "license": "other_open",
            "vendor": "JUnit Team",
            "year_introduced": 2000
          },
          "versioning": {
            "current_version": "5",
            "version_aliases": {
              "junit 4": "4",
              "junit 4.x": "4",
              "junit 5": "5",
              "junit 5.x": "5",
              "junit-jupiter": "5",
              "junit4": "4",
              "junit5": "5"
            },
            "versioned": true
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Frameworks and conventions for writing automated unit tests, assertions, fixtures, and test runners. JUnit belongs here because it is a primary Java unit testing framework used to validate small code units in isolation.",
            "exemplar_skills": [
              "JUnit",
              "JUnit 5",
              "JUnit 4",
              "assertions",
              "test fixtures",
              "parameterized tests",
              "test runners"
            ],
            "in_scope": "JUnit, JUnit 4, JUnit 5, assertions, test fixtures, test lifecycle hooks, parameterized tests, test suites, mocking integration, test runners, test annotations",
            "name": "Unit Testing Frameworks",
            "out_of_scope": "Frontend component testing, browser automation, and end-to-end flows, which belong to frontend-testing-and-e2e-automation; Android device/UI instrumentation, which belongs to android-testing-frameworks; CI pipeline orchestration, which belongs to ci-cd-pipeline-platforms",
            "overlap_flags": [
              {
                "reason": "Both involve automated tests, but JUnit is focused on code-level unit tests rather than browser or UI flows.",
                "with_dim_id": "frontend-testing-and-e2e-automation",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              },
              {
                "reason": "JUnit is often used in Android projects, but Android testing also includes device and instrumentation-specific tooling.",
                "with_dim_id": "android-testing-frameworks",
                "with_dim_name": null,
                "with_role": "Android Engineer"
              },
              {
                "reason": "JUnit test execution is commonly wired into CI, but the framework itself is about test authoring rather than pipeline automation.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "JUnit",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "junit"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "mocks",
            "evaluation-frameworks",
            "code-quality",
            "exception-review",
            "widget-testing",
            "logging",
            "api",
            "xml"
          ],
          "requires": [],
          "skill_id": "junit",
          "suppress_on_match": []
        },
        "skill_id": "junit",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.97,
          "name": "JUnit",
          "reasoning": "JUnit is a structured codebase that developers build and run tests within, so by the Tool vs Framework rule it is a Framework rather than a Tool or Library.",
          "skill_id": "junit",
          "subtype": "testing_framework",
          "type": "Framework"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frontend Testing and E2E Automation",
            "id": 122,
            "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
            "slug": "frontend-testing-and-e2e-automation",
            "source": "db"
          },
          "input_skill": "Selenium",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Selenium",
          "llm_role": null,
          "roles_from_db": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frontend Testing and E2E Automation",
            "id": 122,
            "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
            "slug": "frontend-testing-and-e2e-automation",
            "source": "db"
          },
          "input_skill": "Selenium",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Selenium",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Tool",
          "skill_nature": "TOOL",
          "sub_category": "test_automation_tool",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "Selenium is a specific, widely recognized test automation tool; typical JDs won\u2019t confuse it with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "WebDriver",
              "TestNG",
              "JUnit",
              "Page Object Model",
              "Selenium Grid",
              "Cucumber",
              "JavaScript",
              "Python",
              "XPath",
              "CSS Selectors",
              "Headless Browsers",
              "Cross-Browser Testing",
              "Automation Framework",
              "Continuous Integration",
              "Behavior-Driven Development"
            ]
          },
          "maturity": {
            "confidence": 0.96,
            "maturity": "well_known",
            "reasoning": "Selenium remains a hiring-pipeline staple for QA/E2E roles; it appears in many job descriptions and is still widely used across browser automation stacks, despite newer tools like Playwright gaining share."
          },
          "skill_id": "selenium",
          "vendor_license": {
            "confidence": 0.95,
            "license": "apache_2",
            "vendor": "SeleniumHQ",
            "year_introduced": 2004
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Testing tools and practices used to validate browser-based user flows, UI interactions, and end-to-end application behavior. Selenium belongs here because it automates real browser sessions to verify that web features work as users experience them.",
            "exemplar_skills": [
              "Selenium",
              "Cypress",
              "Playwright",
              "WebDriver",
              "end-to-end testing",
              "browser automation",
              "page object model"
            ],
            "in_scope": "Selenium, Cypress, Playwright, WebDriver-based browser automation, end-to-end tests, UI regression tests, cross-browser validation, smoke tests, user journey automation, test selectors, page objects",
            "name": "Frontend Testing and E2E Automation",
            "out_of_scope": "Unit testing of isolated functions, backend API contract testing, mobile app UI automation, performance/load testing, these belong to other testing or platform dimensions",
            "overlap_flags": [
              {
                "reason": "Browser automation interacts with native browser behavior, but the focus here is validating application flows rather than using browser APIs directly.",
                "with_dim_id": "browser-apis-and-web-platform",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              },
              {
                "reason": "UI frameworks define the components under test, but Selenium is about testing those rendered interfaces rather than building them.",
                "with_dim_id": "ui-frameworks-and-rendering",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer, Hybrid Mobile Developer"
              }
            ],
            "tentative_id": "frontend-testing-and-e2e-automation"
          },
          {
            "description": "Tools and libraries used to drive browsers programmatically for testing, scraping, and scripted interaction. Selenium fits because it provides a general browser automation API and driver ecosystem beyond a single test framework.",
            "exemplar_skills": [
              "Selenium",
              "WebDriver",
              "ChromeDriver",
              "GeckoDriver",
              "headless browser automation",
              "browser scripting",
              "DOM automation"
            ],
            "in_scope": "Selenium, WebDriver, browser drivers, automated clicks and form entry, DOM interaction, browser session control, cross-browser scripting, automation harnesses, headless browser runs",
            "name": "Browser Automation Tooling",
            "out_of_scope": "Test strategy and assertions for product flows, framework-specific UI test suites, backend service testing, these belong to testing or application development dimensions",
            "overlap_flags": [
              {
                "reason": "Selenium is commonly used for frontend E2E tests, so this tooling dimension overlaps with the broader testing dimension.",
                "with_dim_id": "frontend-testing-and-e2e-automation",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              },
              {
                "reason": "Automating browsers touches platform behavior, but this dimension is about automation tooling rather than browser-native APIs.",
                "with_dim_id": "browser-apis-and-web-platform",
                "with_dim_name": null,
                "with_role": "Frontend Engineer, Full Stack Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
            "exemplar_skills": [
              "Frontend Testing and E2E Automation"
            ],
            "in_scope": "Skills, tools, and practices that belong under Frontend Testing and E2E Automation for the target role, including items implied by the dimension rationale.",
            "name": "Frontend Testing and E2E Automation",
            "out_of_scope": "Adjacent clusters explicitly not owned by Frontend Testing and E2E Automation, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "frontend-testing-and-e2e-automation"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Selenium",
          "placement_confidence": 0.92,
          "primary_dimension": "frontend-testing-and-e2e-automation",
          "reasoning": "Deterministic JD placement: locked_dimensions has 3 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "d_init_01"
          ],
          "skill_id": "selenium"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "cross-browser-compatibility",
            "widget-testing",
            "automation-scripts",
            "api-integration",
            "metrics",
            "evaluation"
          ],
          "requires": [],
          "skill_id": "selenium",
          "suppress_on_match": []
        },
        "skill_id": "selenium",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.98,
          "name": "Selenium",
          "reasoning": "Selenium is software you run to automate browsers, so by the Tool vs Framework rule it is a Tool rather than a framework or library.",
          "skill_id": "selenium",
          "subtype": "test_automation_tool",
          "type": "Tool"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:42-\u003e3"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "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": "LoadRunner",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "LoadRunner",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Tool",
          "skill_nature": "TOOL",
          "sub_category": "performance_testing_tool",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "LoadRunner is a specific HP/ALM performance testing tool name; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "VUGen",
              "Controller",
              "Analysis",
              "Load Testing",
              "Performance Metrics",
              "Scripting",
              "Virtual Users",
              "Web Protocols",
              "LoadRunner Cloud",
              "Business Process Testing",
              "Monitoring",
              "Correlation",
              "Parameterization",
              "Performance Bottlenecks",
              "Test Scenarios"
            ]
          },
          "maturity": {
            "confidence": 0.88,
            "maturity": "niche",
            "reasoning": "LoadRunner appears in performance-testing JDs, but far less often than JMeter/k6; market demand is concentrated in legacy enterprise QA roles rather than broad hiring pipelines."
          },
          "skill_id": "loadrunner",
          "vendor_license": {
            "confidence": 0.95,
            "license": "proprietary",
            "vendor": "Micro Focus",
            "year_introduced": 1996
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Tools used to simulate user load, measure response times, and validate system behavior under stress. LoadRunner belongs here because it is a dedicated performance testing platform for load, stress, and endurance testing.",
            "exemplar_skills": [
              "LoadRunner",
              "Apache JMeter",
              "Gatling",
              "k6",
              "NeoLoad"
            ],
            "in_scope": "LoadRunner, Apache JMeter, Gatling, k6, NeoLoad, stress testing, load testing, endurance testing, throughput measurement, response time analysis",
            "name": "Performance Testing Tools",
            "out_of_scope": "Functional UI testing, unit testing, API contract testing, production monitoring, capacity planning strategy, which belong to testing, observability, or operations dimensions",
            "overlap_flags": [
              {
                "reason": "Both can validate user-facing flows, but LoadRunner focuses on performance and scale rather than functional correctness.",
                "with_dim_id": "frontend-testing-and-e2e-automation",
                "with_dim_name": null,
                "with_role": "Frontend Engineer"
              },
              {
                "reason": "Performance test results often inform operational readiness, but this dimension is about generating load rather than monitoring live systems.",
                "with_dim_id": "observability-and-operations",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "d_init_01"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "LoadRunner",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 1 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "loadrunner"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "metrics",
            "logging",
            "distributed-tracing",
            "failure-analysis",
            "automation-scripts",
            "api",
            "mocks",
            "sysdig-runtime"
          ],
          "requires": [],
          "skill_id": "loadrunner",
          "suppress_on_match": []
        },
        "skill_id": "loadrunner",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.98,
          "name": "LoadRunner",
          "reasoning": "LoadRunner is software you run to perform load and performance testing, so by the Tool vs Framework rule it is a Tool rather than a framework or platform.",
          "skill_id": "loadrunner",
          "subtype": "performance_testing_tool",
          "type": "Tool"
        },
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frontend Testing and E2E Automation",
            "id": 122,
            "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
            "slug": "frontend-testing-and-e2e-automation",
            "source": "db"
          },
          "input_skill": "SoapUI",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Frontend Testing and E2E Automation",
            "id": 122,
            "rationale": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
            "slug": "frontend-testing-and-e2e-automation",
            "source": "db"
          },
          "input_skill": "SoapUI",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Engineer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "SoapUI",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Tool",
          "skill_nature": "TOOL",
          "sub_category": "api_testing_tool",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "SoapUI is a specific API testing tool name; unlikely to be confused with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "API testing",
              "SOAP",
              "REST",
              "mock services",
              "load testing",
              "functional testing",
              "assertions",
              "test cases",
              "Groovy scripting",
              "data-driven testing",
              "service virtualization",
              "JUnit integration",
              "test automation",
              "report generation",
              "security testing"
            ]
          },
          "maturity": {
            "confidence": 0.87,
            "maturity": "niche",
            "reasoning": "SoapUI still appears in some API-testing job ads, but JD volume is far below Postman/REST Assured and the market has shifted toward those tools; SmartBear\u2019s own focus is now on ReadyAPI/ReadyAPI Test."
          },
          "skill_id": "soapui",
          "vendor_license": {
            "confidence": 0.95,
            "license": "apache_2",
            "vendor": "SmartBear Software",
            "year_introduced": 2005
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "frontend-testing-and-e2e-automation",
            "a_name": "Frontend Testing and E2E Automation",
            "a_role": "__skill_focal__",
            "b_dim_id": "frontend-testing-and-e2e-automation",
            "b_name": "Frontend Testing and E2E Automation",
            "b_role": "Frontend Engineer",
            "pair_kind": "cross_role",
            "reasoning": "Dim A is API/service-level testing: SoapUI, API functional testing, REST/SOAP validation, HTTP request checks, and service contract checks. Dim B is browser/UI testing: UI behavior, interactions, browser flows, components, pages, and user journeys. The overlap is only in broad E2E wording; the concrete skills and tools differ. career-track: no, because a senior API/SOAP testing practitioner is not naturally a senior frontend browser-automation practitioner.",
            "similarity": 0.8512111648720625
          }
        ],
        "locked_dimensions": [
          {
            "description": "Tools and practices for validating application behavior through automated tests that exercise UI flows, integrations, and service interactions. SoapUI fits here because it is commonly used to test APIs and end-to-end request/response behavior that supports application quality.",
            "exemplar_skills": [
              "SoapUI",
              "API testing",
              "REST API validation",
              "SOAP web service testing",
              "end-to-end automation"
            ],
            "in_scope": "SoapUI, API functional testing, end-to-end test automation, regression test suites, test assertions, service contract checks, HTTP request validation, REST and SOAP testing",
            "name": "Frontend Testing and E2E Automation",
            "out_of_scope": "Unit testing frameworks, browser-only UI automation, load and performance testing, production monitoring and alerting, manual QA execution",
            "overlap_flags": [
              {
                "reason": "API testing often targets services built with web frameworks, but the dimension here is test automation rather than server implementation.",
                "with_dim_id": "web-application-frameworks",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Full Stack Engineer"
              },
              {
                "reason": "SoapUI suites may run in pipelines, but pipeline orchestration is a separate concern from the testing tool itself.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              }
            ],
            "tentative_id": "frontend-testing-and-e2e-automation"
          },
          {
            "description": "Test tools and practices used to validate UI behavior, interactions, and browser flows. Frontend engineers rely on these to catch regressions in components, pages, and user journeys.",
            "exemplar_skills": [
              "Frontend Testing and E2E Automation"
            ],
            "in_scope": "Skills, tools, and practices that belong under Frontend Testing and E2E Automation for the target role, including items implied by the dimension rationale.",
            "name": "Frontend Testing and E2E Automation",
            "out_of_scope": "Adjacent clusters explicitly not owned by Frontend Testing and E2E Automation, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "frontend-testing-and-e2e-automation"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "SoapUI",
          "placement_confidence": 0.92,
          "primary_dimension": "frontend-testing-and-e2e-automation",
          "reasoning": "Deterministic JD placement: locked_dimensions has 2 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [],
          "skill_id": "soapui"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "api",
            "xml",
            "api-integration"
          ],
          "related_to": [
            "widget-testing",
            "automation-scripts",
            "api-security",
            "eclipse",
            "tomcat",
            "websphere"
          ],
          "requires": [],
          "skill_id": "soapui",
          "suppress_on_match": []
        },
        "skill_id": "soapui",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.98,
          "name": "SoapUI",
          "reasoning": "SoapUI is software you run to test and inspect APIs, so by the Tool vs Framework rule it is a Tool rather than something you build applications inside.",
          "skill_id": "soapui",
          "subtype": "api_testing_tool",
          "type": "Tool"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:41-\u003e2"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Serverless Framework",
          "alias_type": "CANONICAL",
          "id": 1345,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "Serverless Framework",
        "id": 800,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "serverless-framework",
        "sub_category_id": 145,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Infrastructure as Code",
            "id": 132,
            "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
            "slug": "infrastructure-as-code",
            "source": "db"
          },
          "input_skill": "Serverless Computing",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Serverless Computing",
      "matched_via": "embedding_alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "CI/CD",
          "alias_type": "CANONICAL",
          "id": 1826,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "CI/CD",
        "id": 1190,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "ci-cd",
        "sub_category_id": 900,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD for Machine Learning",
            "id": 56,
            "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
            "slug": "ci-cd-for-machine-learning",
            "source": "db"
          },
          "input_skill": "CI/CD",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "ML Engineer",
              "id": 3,
              "rationale": null,
              "role_archetype": null,
              "slug": "ml-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "CI/CD",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Infrastructure as Code",
            "id": 132,
            "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
            "slug": "infrastructure-as-code",
            "source": "db"
          },
          "input_skill": "Infrastructure as Code",
          "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": "Environment Provisioning and Parity",
            "id": 157,
            "rationale": "Creating and maintaining consistent dev, test, staging, and production environments. This cluster is coherent because delivery failures often come from environment drift, missing dependencies, or inconsistent configuration.",
            "slug": "environment-provisioning-and-parity",
            "source": "db"
          },
          "input_skill": "Infrastructure as Code",
          "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": "Security Architecture and Hardening",
            "id": 75,
            "rationale": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
            "slug": "security-architecture-and-hardening",
            "source": "db"
          },
          "input_skill": "Infrastructure as Code",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Environment Provisioning and Parity",
            "id": 157,
            "rationale": "Creating and maintaining consistent dev, test, staging, and production environments. This cluster is coherent because delivery failures often come from environment drift, missing dependencies, or inconsistent configuration.",
            "slug": "environment-provisioning-and-parity",
            "source": "db"
          },
          "input_skill": "Infrastructure as Code",
          "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": "Security Architecture and Hardening",
            "id": 75,
            "rationale": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
            "slug": "security-architecture-and-hardening",
            "source": "db"
          },
          "input_skill": "Infrastructure as Code",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Infrastructure as Code",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodology",
          "skill_nature": "METHODOLOGY",
          "sub_category": "infrastructure_as_code",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "\u201cInfrastructure as Code\u201d is a distinct methodology; typical JDs won\u2019t confuse it with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "Terraform",
              "Ansible",
              "CloudFormation",
              "IaC",
              "GitOps",
              "CI/CD",
              "DevOps",
              "Immutable Infrastructure",
              "Configuration Management",
              "Version Control",
              "Automation",
              "Microservices",
              "Containerization",
              "Infrastructure Provisioning",
              "Declarative Syntax"
            ]
          },
          "maturity": {
            "confidence": 0.98,
            "maturity": "well_known",
            "reasoning": "Infrastructure as Code is a hiring-pipeline staple: Terraform, CloudFormation, and Pulumi appear in many DevOps/SRE job descriptions, and major cloud vendors actively support it."
          },
          "skill_id": "infrastructure-as-code",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [
          {
            "a_dim_id": "d_init_01",
            "a_name": "Infrastructure as Code",
            "a_role": "__skill_focal__",
            "b_dim_id": "environment-provisioning-and-parity",
            "b_name": "Environment Provisioning and Parity",
            "b_role": "__skill_focal__",
            "pair_kind": "intra_role",
            "reasoning": "Dim A is about declarative infrastructure authoring and provisioning tools (Terraform, CloudFormation, Pulumi, plan/apply, state). Dim B is about keeping dev/test/staging/prod environments consistent and avoiding drift/missing dependencies. Related, but different clusters: one is the mechanism, the other is the environment-parity outcome. career-track: no, because a senior IaC engineer is not automatically a senior environment-parity practitioner.",
            "similarity": 0.6637376951588224
          },
          {
            "a_dim_id": "d_init_01",
            "a_name": "Infrastructure as Code",
            "a_role": "__skill_focal__",
            "b_dim_id": "security-architecture-and-hardening",
            "b_name": "Security Architecture and Hardening",
            "b_role": "__skill_focal__",
            "pair_kind": "intra_role",
            "reasoning": "Dim A is declarative infrastructure provisioning: Terraform, CloudFormation, Pulumi, Bicep, ARM templates, modules, state management, and plan/apply workflows. Dim B is security architecture/hardening: secure baselines, control patterns, and environment hardening. The overlap is only that both can affect cloud resources; the core skills differ. career-track: no, because a senior IaC engineer is not naturally a senior security architecture and hardening specialist.",
            "similarity": 0.6007772476232759
          },
          {
            "a_dim_id": "environment-provisioning-and-parity",
            "a_name": "Environment Provisioning and Parity",
            "a_role": "__skill_focal__",
            "b_dim_id": "security-architecture-and-hardening",
            "b_name": "Security Architecture and Hardening",
            "b_role": "__skill_focal__",
            "pair_kind": "intra_role",
            "reasoning": "Dim A is about reproducible environment setup and parity across dev/test/staging/prod, with exemplars like Infrastructure as Code, environment provisioning, ephemeral environments, and staging parity. Dim B is about security design and hardening, i.e. secure baselines, control patterns, and safeguards. A senior practitioner in environment provisioning/parity is not naturally a senior practitioner in security architecture/hardening: the former centers on repeatable environment bootstrap and consistency, while the latter centers on security controls, baseline enforcement, and hardening strategy. The cosine similarity is likely driven by both involving infrastructure-level implementation, but the underlying skill clusters are distinct.",
            "similarity": 0.5893024333341649
          }
        ],
        "locked_dimensions": [
          {
            "description": "Declarative definition and automated provisioning of infrastructure using code and templates. This skill belongs here because it focuses on creating, updating, and reviewing cloud and platform resources through repeatable machine-readable definitions.",
            "exemplar_skills": [
              "Infrastructure as Code",
              "Terraform",
              "CloudFormation",
              "Pulumi",
              "Bicep",
              "ARM templates",
              "Ansible provisioning",
              "IaC modules",
              "state management",
              "plan and apply workflows"
            ],
            "in_scope": "Infrastructure as Code, Terraform, CloudFormation, Pulumi, Bicep, ARM templates, Ansible for provisioning, declarative resource definitions, modules, state management, plan/apply workflows",
            "name": "Infrastructure as Code",
            "out_of_scope": "CI/CD pipeline orchestration, which owns build and deployment workflow automation; cloud configuration review, which focuses on auditing existing resources rather than defining them; security hardening, which covers baseline controls and secure configuration outcomes",
            "overlap_flags": [
              {
                "reason": "IaC is often used to create consistent environments, but that dimension centers on environment lifecycle and parity rather than the provisioning language itself.",
                "with_dim_id": "environment-provisioning-and-parity",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              },
              {
                "reason": "IaC targets resources on specific cloud providers, but the platform dimension is about the providers and managed services themselves.",
                "with_dim_id": "cloud-platforms",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, Full Stack Engineer, ML Engineer, ML Ops Engineer"
              },
              {
                "reason": "IaC frequently encodes security controls, but secure baseline design is owned by the security architecture dimension.",
                "with_dim_id": "security-architecture-and-hardening",
                "with_dim_name": null,
                "with_role": "Cybersecurity Engineer"
              }
            ],
            "tentative_id": "d_init_01"
          },
          {
            "description": "Creating consistent development, test, staging, and production environments with repeatable setup. Infrastructure as Code belongs here when the emphasis is on making environments reproducible and aligned across stages.",
            "exemplar_skills": [
              "Infrastructure as Code",
              "environment provisioning",
              "environment parity",
              "ephemeral environments",
              "repeatable setup",
              "environment templates",
              "staging parity",
              "dev/test/prod consistency"
            ],
            "in_scope": "development environment setup, staging parity, production-like test environments, repeatable environment bootstrap, Infrastructure as Code, environment templates, ephemeral environments, configuration consistency",
            "name": "Environment Provisioning and Parity",
            "out_of_scope": "Application deployment pipelines, which own build and release automation; cloud resource design, which owns provider-specific infrastructure choices; runtime observability, which covers monitoring after environments are live",
            "overlap_flags": [
              {
                "reason": "Environment provisioning is often automated through CI/CD, but the pipeline dimension is about workflow engines and release automation.",
                "with_dim_id": "ci-cd-pipeline-platforms",
                "with_dim_name": null,
                "with_role": "DevOps Engineer"
              },
              {
                "reason": "Environment provisioning usually targets cloud resources, but the cloud platform dimension is about the underlying provider ecosystem.",
                "with_dim_id": "cloud-platforms",
                "with_dim_name": null,
                "with_role": "Backend Engineer, Cybersecurity Engineer, Data Engineer, DevOps Engineer, Full Stack Engineer, ML Engineer, ML Ops Engineer"
              }
            ],
            "tentative_id": "environment-provisioning-and-parity"
          },
          {
            "description": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. Infrastructure as Code fits when it is used to codify secure infrastructure defaults, guardrails, and compliant resource configurations.",
            "exemplar_skills": [
              "Infrastructure as Code",
              "policy as code",
              "secure baseline templates",
              "hardened infrastructure",
              "least-privilege configuration",
              "secure landing zones",
              "guardrail enforcement",
              "compliant infrastructure modules"
            ],
            "in_scope": "secure baseline templates, policy-as-code, hardened network and compute defaults, least-privilege resource configuration, Infrastructure as Code, guardrail enforcement, compliant infrastructure modules, secure landing zones",
            "name": "Security Architecture and Hardening",
            "out_of_scope": "General provisioning of servers and networks without security intent, which belongs to infrastructure automation; identity federation and access management, which belongs to identity architecture; incident handling, which belongs to response and coordination",
            "overlap_flags": [
              {
                "reason": "IaC can define IAM roles and permissions, but identity architecture owns authentication, authorization, and federation patterns.",
                "with_dim_id": "identity-and-access-architecture",
                "with_dim_name": null,
                "with_role": "Cloud Architect, Cloud Security Engineer"
              },
              {
                "reason": "Both touch cloud settings, but review is about assessing existing configurations while this dimension is about defining secure ones.",
                "with_dim_id": "cloud-configuration-review",
                "with_dim_name": null,
                "with_role": "Cloud Security Engineer"
              }
            ],
            "tentative_id": "security-architecture-and-hardening"
          },
          {
            "description": "Creating and maintaining consistent dev, test, staging, and production environments. This cluster is coherent because delivery failures often come from environment drift, missing dependencies, or inconsistent configuration.",
            "exemplar_skills": [
              "Environment Provisioning and Parity"
            ],
            "in_scope": "Skills, tools, and practices that belong under Environment Provisioning and Parity for the target role, including items implied by the dimension rationale.",
            "name": "Environment Provisioning and Parity",
            "out_of_scope": "Adjacent clusters explicitly not owned by Environment Provisioning and Parity, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "environment-provisioning-and-parity"
          },
          {
            "description": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
            "exemplar_skills": [
              "Security Architecture and Hardening"
            ],
            "in_scope": "Skills, tools, and practices that belong under Security Architecture and Hardening for the target role, including items implied by the dimension rationale.",
            "name": "Security Architecture and Hardening",
            "out_of_scope": "Adjacent clusters explicitly not owned by Security Architecture and Hardening, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "security-architecture-and-hardening"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "Infrastructure as Code",
          "placement_confidence": 0.92,
          "primary_dimension": "d_init_01",
          "reasoning": "Deterministic JD placement: locked_dimensions has 5 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "environment-provisioning-and-parity",
            "security-architecture-and-hardening"
          ],
          "skill_id": "infrastructure-as-code"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [
            "terraform",
            "aws-cloudformation-dsl",
            "aws-cdk",
            "azure-policy"
          ],
          "related_to": [
            "code-quality",
            "api-security",
            "ipsec",
            "azure-defender-for-cloud",
            "offline-first",
            "api-integration"
          ],
          "requires": [
            "policy-as-code",
            "aws-identity-and-access-management-iam",
            "nist-800-53",
            "site-reliability-engineering"
          ],
          "skill_id": "infrastructure-as-code",
          "suppress_on_match": []
        },
        "skill_id": "infrastructure-as-code",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.91,
          "name": "Infrastructure as Code",
          "reasoning": "By the Concept vs Methodology rule, Infrastructure as Code is a way of working for provisioning and managing infrastructure, not a software artifact or system shape.",
          "skill_id": "infrastructure-as-code",
          "subtype": "infrastructure_as_code",
          "type": "Methodology"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:43-\u003e5"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Agile",
          "alias_type": "CANONICAL",
          "id": 868,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "Agile",
        "id": 520,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "agile",
        "sub_category_id": 367,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Agile",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Agile",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "design patterns",
          "alias_type": "CANONICAL",
          "id": 2624,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "design patterns",
        "id": 1654,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "design-patterns",
        "sub_category_id": 1247,
        "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": "Design Patterns",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Design Patterns",
      "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": "DevOps",
          "alias_type": "CANONICAL",
          "id": 1852,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "DevOps",
        "id": 1216,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "devops",
        "sub_category_id": 922,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CI/CD Pipeline Platforms",
            "id": 150,
            "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
            "slug": "ci-cd-pipeline-platforms",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Deployment and Release Patterns",
            "id": 140,
            "rationale": "Patterns for promoting changes safely across environments, including rollout, rollback, and release gating strategies. Cloud Architects define these patterns so teams can deploy consistently across the platform.",
            "slug": "deployment-and-release-patterns",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Infrastructure as Code",
            "id": 132,
            "rationale": "Declarative provisioning and environment definition tools used to codify cloud infrastructure, repeatable environments, and platform standards. Cloud Architects use these to express reference architectures and guardrails.",
            "slug": "infrastructure-as-code",
            "source": "db"
          },
          "input_skill": "DevOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            },
            {
              "display_name": "DevOps Engineer",
              "id": 10,
              "rationale": null,
              "role_archetype": null,
              "slug": "devops-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "DevOps",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Security Architecture and Hardening",
            "id": 75,
            "rationale": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
            "slug": "security-architecture-and-hardening",
            "source": "db"
          },
          "input_skill": "SecOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Configuration Review",
            "id": 244,
            "rationale": "Review practices for evaluating cloud resources against security baselines and approved control requirements. This includes reading configurations, identifying drift, and documenting remediation guidance for owning teams.",
            "slug": "cloud-configuration-review",
            "source": "db"
          },
          "input_skill": "SecOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Configuration Review",
            "id": 244,
            "rationale": "Review practices for evaluating cloud resources against security baselines and approved control requirements. This includes reading configurations, identifying drift, and documenting remediation guidance for owning teams.",
            "slug": "cloud-configuration-review",
            "source": "db"
          },
          "input_skill": "SecOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Security Engineer",
              "id": 23,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-security-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Security Architecture and Hardening",
            "id": 75,
            "rationale": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
            "slug": "security-architecture-and-hardening",
            "source": "db"
          },
          "input_skill": "SecOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cybersecurity Engineer",
              "id": 5,
              "rationale": null,
              "role_archetype": null,
              "slug": "cybersecurity-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "SecOps",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Methodology",
          "skill_nature": "METHODOLOGY",
          "sub_category": "security_operations_methodology",
          "typical_lifespan": "EVERGREEN",
          "version_strategy": "NOT_APPLICABLE",
          "volatility": "STABLE"
        },
        "enrichment": {
          "ambiguity": {
            "ambiguity_flag": false,
            "confused_with": [],
            "reasoning": "SecOps is a distinct security operations methodology; typical JDs won\u2019t confuse it with other catalog skills."
          },
          "context_keywords": {
            "context_keywords": [
              "incident response",
              "threat hunting",
              "vulnerability management",
              "security monitoring",
              "SIEM",
              "firewall management",
              "malware analysis",
              "risk assessment",
              "compliance auditing",
              "penetration testing",
              "security orchestration",
              "automated response",
              "log analysis",
              "network segmentation",
              "endpoint protection"
            ]
          },
          "maturity": {
            "confidence": 0.9,
            "maturity": "well_known",
            "reasoning": "SecOps is broadly listed in security and DevOps job descriptions, with vendors like Microsoft, AWS, and Splunk offering SecOps products and training, indicating mainstream hiring demand."
          },
          "skill_id": "secops",
          "vendor_license": {
            "confidence": 0.95,
            "license": null,
            "vendor": null,
            "year_introduced": null
          },
          "versioning": {
            "current_version": null,
            "version_aliases": {},
            "versioned": false
          }
        },
        "keep_log": [],
        "locked_dimensions": [
          {
            "description": "Operational security practices for securing systems, environments, and controls in day-to-day engineering work. SecOps fits here when it refers to applying security baselines, hardening, and secure operational guardrails across infrastructure and services.",
            "exemplar_skills": [
              "SecOps",
              "security hardening",
              "secure configuration management",
              "vulnerability remediation",
              "least privilege",
              "secrets management",
              "patch management"
            ],
            "in_scope": "SecOps, secure baselines, hardening standards, patching strategy, secure configuration, secrets handling, vulnerability remediation, security guardrails, least privilege, secure defaults, policy enforcement",
            "name": "Security Operations Hardening",
            "out_of_scope": "Incident triage and breach handling, which belongs to incident-response-and-coordination; SIEM rule authoring and alert queries, which belongs to siem-products-and-detection-engineering-languages; Kubernetes-specific cluster controls, which belongs to container-and-kubernetes-security",
            "overlap_flags": [
              {
                "reason": "SecOps often overlaps with incident handling, but response coordination is a distinct operational workflow.",
                "with_dim_id": "incident-response-and-coordination",
                "with_dim_name": null,
                "with_role": "Cloud Security Engineer, Cybersecurity Engineer"
              },
              {
                "reason": "SecOps may include container hardening, but Kubernetes-specific controls are a separate specialization.",
                "with_dim_id": "container-and-kubernetes-security",
                "with_dim_name": null,
                "with_role": "Cloud Security Engineer, Cybersecurity Engineer"
              }
            ],
            "tentative_id": "security-architecture-and-hardening"
          },
          {
            "description": "Reviewing cloud resources and operational settings for security misconfigurations, drift, and control compliance. SecOps belongs here when it means continuously checking cloud posture and correcting risky configurations.",
            "exemplar_skills": [
              "SecOps",
              "cloud configuration review",
              "security posture management",
              "misconfiguration detection",
              "IAM review",
              "network exposure analysis",
              "control validation"
            ],
            "in_scope": "SecOps, cloud posture review, configuration audits, security baseline checks, IAM review, network exposure review, storage access review, drift detection, control validation, misconfiguration remediation",
            "name": "Cloud Security Operations Review",
            "out_of_scope": "Identity design and federation architecture, which belongs to identity-and-access-architecture; runtime detection engineering and SIEM queries, which belongs to siem-products-and-detection-engineering-languages; general observability and service monitoring, which belongs to observability-and-operations",
            "overlap_flags": [
              {
                "reason": "Cloud security operations often reviews IAM settings, but identity architecture owns the design of authn/authz patterns.",
                "with_dim_id": "identity-and-access-architecture",
                "with_dim_name": null,
                "with_role": "Cloud Architect, Cloud Security Engineer"
              },
              {
                "reason": "SecOps can use monitoring signals, but operational observability is broader than security review.",
                "with_dim_id": "observability-and-operations",
                "with_dim_name": null,
                "with_role": "Cloud Architect"
              }
            ],
            "tentative_id": "cloud-configuration-review"
          },
          {
            "description": "Review practices for evaluating cloud resources against security baselines and approved control requirements. This includes reading configurations, identifying drift, and documenting remediation guidance for owning teams.",
            "exemplar_skills": [
              "Cloud Configuration Review"
            ],
            "in_scope": "Skills, tools, and practices that belong under Cloud Configuration Review for the target role, including items implied by the dimension rationale.",
            "name": "Cloud Configuration Review",
            "out_of_scope": "Adjacent clusters explicitly not owned by Cloud Configuration Review, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "cloud-configuration-review"
          },
          {
            "description": "Design and implementation of secure baselines, control patterns, and environment hardening across systems. This cluster is central to the role because it turns policy and risk analysis into concrete technical safeguards.",
            "exemplar_skills": [
              "Security Architecture and Hardening"
            ],
            "in_scope": "Skills, tools, and practices that belong under Security Architecture and Hardening for the target role, including items implied by the dimension rationale.",
            "name": "Security Architecture and Hardening",
            "out_of_scope": "Adjacent clusters explicitly not owned by Security Architecture and Hardening, including unrelated platforms, roles, and skill families per library policy.",
            "overlap_flags": [],
            "tentative_id": "security-architecture-and-hardening"
          }
        ],
        "merge_log": [],
        "placed": {
          "name": "SecOps",
          "placement_confidence": 0.92,
          "primary_dimension": "security-architecture-and-hardening",
          "reasoning": "Deterministic JD placement: locked_dimensions has 4 dimension(s) from skill-driven dimension generation after reconciliation; primary_dimension is the first locked dim.",
          "secondary_dimensions": [
            "cloud-configuration-review"
          ],
          "skill_id": "secops"
        },
        "relationships": {
          "child_skills": [],
          "parent_skills": [],
          "related_to": [
            "defense-in-depth",
            "site-reliability-engineering",
            "api-security",
            "nist-csf",
            "soc-2",
            "iso-27001",
            "pci-dss",
            "fedramp"
          ],
          "requires": [],
          "skill_id": "secops",
          "suppress_on_match": []
        },
        "skill_id": "secops",
        "split_log": [],
        "typed": {
          "alternatives_considered": [],
          "confidence": 0.9,
          "name": "SecOps",
          "reasoning": "SecOps is fundamentally a way of working that integrates security into operations, so by the Concept vs Methodology rule it fits Methodology rather than a tool or platform.",
          "skill_id": "secops",
          "subtype": "security_operations_methodology",
          "type": "Methodology"
        },
        "warnings": [
          "stage3_post_filter_dropped_catalog_only_locked_dims:42-\u003e4"
        ]
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "FinOps",
          "alias_type": "CANONICAL",
          "id": 1315,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 8,
        "display_name": "FinOps",
        "id": 770,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "METHODOLOGY",
        "slug": "finops",
        "sub_category_id": 545,
        "typical_lifespan": "EVERGREEN",
        "volatility": "EMERGING"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cloud Cost and FinOps",
            "id": 142,
            "rationale": "Cost governance and optimization practices used to align cloud consumption with budgets and business value. Cloud Architects need this to shape service selection, environment sizing, and platform standards.",
            "slug": "cloud-cost-and-finops",
            "source": "db"
          },
          "input_skill": "FinOps",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Cloud Architect",
              "id": 9,
              "rationale": null,
              "role_archetype": null,
              "slug": "cloud-architect",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "FinOps",
      "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": [
    "Bootstrap",
    "SOA",
    "SVN",
    "XP",
    "JIRA",
    "Confluence",
    "JUnit",
    "Selenium",
    "LoadRunner",
    "SoapUI",
    "Infrastructure as Code",
    "SecOps"
  ]
}
API 3 — final-role-output
{}

LLM Calls

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

Loading…