← Back to history

Pipeline run

e72afe83-94db-4905-a448-89e895aef164

Pipeline LLM cost (USD)
API 1: $0.0125 API 2: $0.0003 API 3: $0.0000 Total: $0.0128

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 · Cross-platform feature development
Build and maintain React Native mobile apps in TypeScript, refactor code to architecture and design standards, write tests with RTL/Jest/Detox, and work in Gitflow/Scrum with code reviews and release support.
""Development and ongoing maintenance of mobile applications built with TypeScript using React Native""
Tech stack maturity
Modern Cloud Native
The skill set centers on React Native, Redux Toolkit, TypeScript, Jest, and mobile development in Kotlin and Swift, which aligns with contemporary cross-platform app development practices and modern tooling.
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 (24)
TypeScript React Native Swift Kotlin React Testing Library Jest Git GitHub Gitflow Redux Redux Toolkit Detox Scrum Code Review Redux-Logic Redux-Saga Formik React Hook Form JSON API Metro Bundler AR libraries Reanimated Styled Components Store normalization
Skill cluster (7 dimension groups, role-scoped)
Mobile Testing Frameworks
Jest Detox
Build and Release Tooling
Metro Bundler
Cross-Platform App Languages
TypeScript
Native Mobile Languages
Kotlin
Screen Navigation and State
Redux
UI Frameworks and Rendering
React Native
Cross-cutting / unaligned
Swift React Testing Library Git GitHub Gitflow Redux Toolkit Scrum Code Review Redux-Logic Redux-Saga Formik React Hook Form JSON API AR libraries Reanimated Styled Components Store normalization
Show KRA description ↓
- Development and ongoing maintenance of mobile applications built with TypeScript using React Native and fundamental approaches of native development (Swift/Kotlin); - Creating solutions and algorithms in accordance with technical specifications or other required documentation; - Writing program code following the prescribed application architecture; - Analyzing and refactoring code using design patterns and established standards; - Writing unit tests (React-testing-library, Jest, Detox as a plus); - Identifying code smells and performing refactoring using design patterns and accepted standards; - Estimating tasks and working to meet deadlines, providing timely updates if rescheduling or deadline adjustments are necessary; - Designing, developing, and maintaining client-side mobile applications; - Participating in the Code Review process and offering constructive feedback on code developed by other developers; - Collaborating with teammates to provide guidance on patterns and behaviors employed in the web/mobile platform; - Employing Git and GitHub to manage code in accordance with Gitflow standards; - Taking part in team Scrum activities such as Refinement, Estimation, Grooming, Sprint Planning, Daily Standup, Sprint Review, and Retrospective. - Strong proficiency and substantial hands-on experience with React Native at least 5 years; - Knowledge and practice experience with Basic Swift/Kotlin; - Proven capability in utilizing Typescript effectively to craft robust and scalable mobile applications; - Knowledge of Redux and Redux Toolkit; - Hands-on exposure to Redux-Logic and Redux-Saga; - Practical experience utilizing React Testing Library to ensure the robustness of codebase; - Experience leveraging Formik and React Hook Form; - Experience working with Jest; - Practical experience with JSON API, working with data interchange formats; - Experience utilizing Git and adhering to Gitflow practices; - Familiarity with Metro Bundler; - English language proficiency at the Intermediate level or higher. - Experience with Detox for testing; - Experience with AR libraries; - Experience with Reanimated for animations; - Experience with Getting apps out into the world with publishing experience; - Experience with Styled Components; - Experience with Store normalization techniques.

Signals

Skill frontend-engineer
0.55
Alias
KRA node-backend-developer
0.62

Post-classification

Centroidupdated · n=69
Alias collision log
New-role queue
New skills captured10
New KRA capturedyes

Captured for admin review

Gitflow primary Hybrid Mobile Developer pending
Redux-Logic Hybrid Mobile Developer pending
Redux-Saga Hybrid Mobile Developer pending
Formik Hybrid Mobile Developer pending
React Hook Form Hybrid Mobile Developer pending
JSON API Hybrid Mobile Developer pending
AR libraries Hybrid Mobile Developer pending
Reanimated Hybrid Mobile Developer pending
Styled Components Hybrid Mobile Developer pending
Store normalization Hybrid Mobile Developer pending
R&R fragment (sim 0.00) Hybrid Mobile Developer pending

- Development and ongoing maintenance of mobile applications built with TypeScript using React Native and fundamental approaches of native development (Swift/Kotlin); - Creating solutions and algorith…

Status: completed Created: 2026-05-27T16:25:59.991919Z Updated: 2026-05-27T16:28:20.641597Z API 3 duration: 83045 ms
Flow Current 3-step pipeline

1 POST /skills/extract-from-jd

2 POST /skills/extract-details

3 POST /skills/final-role-output

Role Chosen role & resolution

Hybrid Mobile Developer

React Native Developer

sub-role · 0.99 domain · Software Engineering CASE DOMAIN

slug: hybrid-mobile-developer · id: 11 · source: db · sub-role slug: react-native-developer

Domain=Software Engineering → sub-role react-native-developer; The JD is centered on React Native mobile app development with TypeScript and related mobile testing, state management, and publishing workflows, which best matches Hybrid Mobile Developer.

Matched skills

TypeScriptReact NativeSwiftKotlinReact-testing-libraryJestDetoxReduxRedux ToolkitRedux-LogicRedux-SagaFormikReact Hook FormJSON APIGitGitHubGitflowMetro BundlerAR librariesReanimated

Matched dimensions

Mobile App DevelopmentClient-side Mobile Application EngineeringCross-platform Mobile DevelopmentUnit and End-to-End TestingState Management and Data NormalizationCode Review and RefactoringAgile Scrum CollaborationApp Publishing and Release Management

Matched KRAs

Development and ongoing maintenance of mobile applicationsCreating solutions and algorithms in accordance with technical specificationsWriting program code following the prescribed application architectureAnalyzing and refactoring code using design patternsWriting unit testsIdentifying code smells and performing refactoringEstimating tasks and working to meet deadlinesParticipating in the Code Review processCollaborating with teammates to provide guidanceTaking part in team Scrum activities

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

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

Job description

Responsibilities:
- Development and ongoing maintenance of mobile applications built with TypeScript using React Native and fundamental approaches of native development (Swift/Kotlin);
- Creating solutions and algorithms in accordance with technical specifications or other required documentation;
- Writing program code following the prescribed application architecture;
- Analyzing and refactoring code using design patterns and established standards;
- Writing unit tests (React-testing-library, Jest, Detox as a plus);
- Identifying code smells and performing refactoring using design patterns and accepted standards;
- Estimating tasks and working to meet deadlines, providing timely updates if rescheduling or deadline adjustments are necessary;
- Designing, developing, and maintaining client-side mobile applications;
- Participating in the Code Review process and offering constructive feedback on code developed by other developers;
- Collaborating with teammates to provide guidance on patterns and behaviors employed in the web/mobile platform;
- Employing Git and GitHub to manage code in accordance with Gitflow standards;
- Taking part in team Scrum activities such as Refinement, Estimation, Grooming, Sprint Planning, Daily Standup, Sprint Review, and Retrospective.


Requirements:
- Strong proficiency and substantial hands-on experience with React Native at least 5 years;
- Knowledge and practice experience with Basic Swift/Kotlin;
- Proven capability in utilizing Typescript effectively to craft robust and scalable mobile applications;
- Knowledge of Redux and Redux Toolkit;
- Hands-on exposure to Redux-Logic and Redux-Saga;
- Practical experience utilizing React Testing Library to ensure the robustness of codebase;
- Experience leveraging Formik and React Hook Form;
- Experience working with Jest;
- Practical experience with JSON API, working with data interchange formats;
- Experience utilizing Git and adhering to Gitflow practices;
- Familiarity with Metro Bundler;
- English language proficiency at the Intermediate level or higher.
- Experience with Detox for testing;
- Experience with AR libraries;
- Experience with Reanimated for animations;
- Experience with Getting apps out into the world with publishing experience;
- Experience with Styled Components;
- Experience with Store normalization techniques.

Skills from this JD

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

TypeScript Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: TypeScript id=524 · typescript

Aliases — catalog

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

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cross-Platform App Languages Catalog dimension db id 167

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer

  • JavaScript and TypeScript Catalog dimension db id 114

    Library dimension (catalog)

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

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

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

  • Programming Languages for XR Catalog dimension db id 97

    Library dimension (catalog)

    Roles linked in library: AR/VR Engineer

  • Sitecore Development Languages Catalog dimension db id 438

    Library dimension (catalog)

    Roles linked in library: Sitecore Dev

API 3 link attempts (this skill)

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

Aliases — catalog

  • React Native (CANONICAL) primary

Context tags (catalog)

Android Component Lifecycle Cross-Platform Expo Firebase GraphQL Hooks Hot Reloading JavaScript Jest MobX Mobile UI Native Modules REST API React Hooks React Navigation Redux State Management Styled Components TypeScript UI Kitten iOS

Stored enrichment (catalog DB)

Category
Framework
Sub-category
Mobile App Framework
Vendor
Meta
License
mit
Year introduced
2015
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: React Native appears in many mobile engineer job descriptions and is widely used in production apps by major vendors, indicating strong hiring-pipeline demand rather than niche adoption.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Cross-Platform Mobile UI Frameworks Catalog dimension db id 319

    Library dimension (catalog)

    Roles linked in library: React Native Developer

  • UI Frameworks and Rendering Catalog dimension db id 115

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Cross-Platform Mobile UI Frameworks
cross-platform-mobile-ui-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension saved
Swift Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Swift id=440 · swift

Aliases — catalog

  • Swift (CANONICAL) primary
  • Swift 2.0 (VERSION)
  • Swift 2.x (VERSION)
  • Swift 3.0 (VERSION)
  • Swift 3.x (VERSION)
  • Swift 4.0 (VERSION)
  • Swift 4.x (VERSION)
  • Swift 5.0 (VERSION)
  • Swift 5.x (VERSION)
  • Swift 6.0 (VERSION)
  • Swift 6.x (VERSION)

Context tags (catalog)

ARC Cocoa Cocoa Touch CocoaPods Combine Core Data Grand Central Dispatch MVVM Objective-C Optionals SPM Swift Package Manager SwiftUI UIKit Xcode async/await asynchronous programming closure closures error handling iOS Development protocol-oriented programming type safety

Stored enrichment (catalog DB)

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

Maturity reasoning: Swift is broadly used for iOS/macOS hiring; job postings commonly list it alongside UIKit/SwiftUI, and Apple continues to invest in it as the primary language for new app development.

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)

  • Native Mobile Languages Catalog dimension db id 274

    Library dimension (catalog)

    Roles linked in library: Native Mobile Developer

  • Swift and Objective-C Catalog dimension db id 81

    Library dimension (catalog)

    Roles linked in library: iOS Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Swift and Objective-C
swift-and-objective-c
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Kotlin id=2 · kotlin

Aliases — catalog

  • Kotlin (CANONICAL) primary
  • kotlin 1.9 (VERSION)
  • kotlin 1.9.0 (VERSION)
  • kotlin 1.9.1 (VERSION)
  • kotlin 1.9.10 (VERSION)
  • kotlin 1.9.x (VERSION)
  • kotlin-1.9 (VERSION)

Context tags (catalog)

Android Anko Coroutines DSL Dagger Data classes Extension functions Flow Gradle Hilt JUnit Jetpack Jetpack Compose Kotlin DSL Kotlin Native Kotlinx Ktor MVI MVVM Mockito Multiplatform Null safety Retrofit Room RxKotlin Sealed classes Spring Type inference

Stored enrichment (catalog DB)

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

Maturity reasoning: Kotlin appears in many Android, backend, and multiplatform job postings, and JetBrains reports strong ecosystem growth; it’s a mainstream hiring skill rather than niche.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Java Language and JVM Catalog dimension db id 279

    Library dimension (catalog)

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

  • Kotlin and Java Catalog dimension db id 161

    Library dimension (catalog)

    Roles linked in library: Android Developer

  • Native Mobile Languages Catalog dimension db id 274

    Library dimension (catalog)

    Roles linked in library: Native Mobile Developer

  • Programming Languages Catalog dimension db id 1

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Java Language and JVM
java-language-and-jvm
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin and Java
kotlin-and-java
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Testing Library Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: React Testing Library id=2548 · react-testing-library

Aliases — catalog

  • React Testing Library (CANONICAL) primary

Context tags (catalog)

Jest RTL accessibility testing asynchronous testing debugging fireEvent integration tests mocking queries react-hooks screen snapshot testing test cases test-driven development unit tests user interactions

Stored enrichment (catalog DB)

Category
Library
Sub-category
Testing Library
Vendor
Testing Library
License
mit
Year introduced
2018
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Common in React job descriptions and testing stacks; widely adopted alongside Jest/Vitest for component testing, with strong GitHub usage and ecosystem docs.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Frontend Testing and E2E Automation Catalog dimension db id 122

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Frontend Testing and E2E Automation
frontend-testing-and-e2e-automation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Jest Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Jest id=651 · jest

Aliases — catalog

  • Jest (CANONICAL) primary

Context tags (catalog)

Babel CLI Enzyme JSDOM Jest CLI React Testing Library React testing TypeScript async tests asynchronous testing asynchronous tests babel-jest beforeEach code coverage configuration configuration files coverage coverage reports coverage thresholds describe enzyme expect integration tests it jest-cli jest.config.js jest.fn jest.fn() jest.mock jest.mock() jsdom matchers mock functions mocking setupFiles setupFilesAfterEnv snapshot testing test environment test runner test suites testMatch unit tests watch mode

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Testing Tool
Vendor
Facebook
License
mit
Year introduced
2014
Confidence
0.96
Version strategy
NOT_APPLICABLE

Maturity reasoning: Jest appears in many frontend and Node.js job descriptions and remains a standard testing framework in React ecosystems; its GitHub usage and ecosystem integrations are still strong.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Frontend Testing and E2E Automation Catalog dimension db id 122

    Library dimension (catalog)

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

  • Mobile Testing Frameworks Catalog dimension db id 168

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer, Native Mobile Developer, React Native Developer

  • Testing and Integration Validation Catalog dimension db id 217

    Library dimension (catalog)

    Roles linked in library: Fullstack Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Frontend Testing and E2E Automation
frontend-testing-and-e2e-automation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Mobile Testing Frameworks
mobile-testing-frameworks
Existing dimension (library) · Role↔dimension saved
Testing and Integration Validation
testing-and-integration-validation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Detox Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Detox id=1061 · detox

Aliases — catalog

  • Detox (CANONICAL) primary

Context tags (catalog)

Appium CI/CD Cypress JavaScript Jest Mocha React Native UI testing continuous integration cross-platform debugging e2e testing end-to-end testing integration testing integration tests mobile testing mocking performance testing snapshot testing test automation test runner

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Mobile E2E Testing Tool
Vendor
Wix
License
mit
Year introduced
2015
Confidence
0.97
Version strategy
NOT_APPLICABLE

Maturity reasoning: Detox appears in a limited slice of React Native mobile E2E testing JDs and GitHub usage, but it is not a broad hiring-pipeline staple like Playwright/Cypress.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Mobile Testing Frameworks Catalog dimension db id 168

    Library dimension (catalog)

    Roles linked in library: Hybrid Mobile Developer, Native Mobile Developer, React Native Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Mobile Testing Frameworks
mobile-testing-frameworks
Existing dimension (library) · Role↔dimension saved
Git Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Git id=1002 · git

Aliases — catalog

  • Git (CANONICAL)

Context tags (catalog)

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

Stored enrichment (catalog DB)

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

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GitHub Primary Library skill API 3: existing canonical (in_db) 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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Gitflow Primary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Practices
Sub-category
general
Skill nature
PRACTICE
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Scrum Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Scrum id=1215 · scrum

Aliases — catalog

  • Scrum (CANONICAL) primary

Context tags (catalog)

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

Stored enrichment (catalog DB)

Category
Methodology
Sub-category
Scrum
Confidence
0.99
Version strategy
NOT_APPLICABLE

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

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

  • Software Concepts, Patterns & Practices Catalog dimension db id 478

    Library dimension (catalog)

    Roles linked in library: Engineering Manager

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Software Concepts, Patterns & Practices
software-concepts-patterns-practices
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Code Review Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Code Review id=516 · code-review

Aliases — catalog

  • Code Review (CANONICAL)

Context tags (catalog)

Bitbucket GitHub GitLab PR review approval workflow branch protection code quality diff inline comments linting merge request pair programming pull request review checklist static analysis

Stored enrichment (catalog DB)

Category
SoftSkill
Sub-category
Code Review
Confidence
0.96
Version strategy
NOT_APPLICABLE

Maturity reasoning: Code review is a standard hiring-pipeline requirement in engineering JDs and is built into major platforms like GitHub/GitLab pull-request workflows, indicating broad adoption.

Skill profile (library / DB)

Skill nature
PRACTICE
Volatility
STABLE
Typical lifespan
EVERGREEN
Category id
58
Sub-category id
364
Extractable
True
Also category
False

Dimensions (API 2 worklist)

  • React Frontend Development Catalog dimension db id 96

    Library dimension (catalog)

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Redux Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Redux id=617 · redux

Aliases — catalog

  • Redux (CANONICAL) primary

Context tags (catalog)

DevTools RTK Query React Redux Toolkit Saga Thunk actions combineReducers connect devtools dispatch immutable immutable state mapDispatchToProps mapStateToProps middleware normalized state reducers redux-persist redux-saga redux-toolkit sagas selector selectors state management state tree store thunk

Stored enrichment (catalog DB)

Category
Library
Sub-category
State Management Library
Vendor
Facebook
License
mit
Year introduced
2015
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Redux remains widely listed in frontend job descriptions and is still a common state-management skill in React stacks, though many teams now prefer Redux Toolkit or alternatives like Zustand for new work.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Screen Navigation and State Catalog dimension db id 83

    Library dimension (catalog)

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

  • State Management Patterns Catalog dimension db id 116

    Library dimension (catalog)

    Roles linked in library: Angular Frontend Developer, Flutter Developer, Frontend Developer, Ionic Developer, React Frontend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Screen Navigation and State
screen-navigation-and-state
Existing dimension (library) · Role↔dimension saved
State Management Patterns
state-management-patterns
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Redux Toolkit Primary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Redux Toolkit id=2519 · redux-toolkit

Aliases — catalog

  • Redux Toolkit (CANONICAL) primary

Context tags (catalog)

action creators configureStore createAsyncThunk createSlice devtools immer immutable state middleware reducer redux devtools extension redux-saga redux-thunk selectors slice state normalization

Stored enrichment (catalog DB)

Category
Library
Sub-category
State Management Library
Vendor
Redux Team
License
mit
Year introduced
2019
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Common in React job postings and the official Redux docs position it as the standard recommended way to write Redux logic, replacing hand-written Redux boilerplate.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • State Management Patterns Catalog dimension db id 116

    Library dimension (catalog)

    Roles linked in library: Angular Frontend Developer, Flutter Developer, Frontend Developer, Ionic Developer, React Frontend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
State Management Patterns
state-management-patterns
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Redux-Logic Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Web Frameworks
Sub-category
State Management
Skill nature
TOOL
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED
Redux-Saga Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Web Frameworks
Sub-category
State Management
Skill nature
TOOL
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED
Formik Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Web Frameworks
Sub-category
Forms
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
React Hook Form Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: React Hooks id=2594 · react-hooks

Aliases — catalog

  • React Hooks (CANONICAL) primary

Context tags (catalog)

React DevTools React Router React Testing Library component lifecycle context API custom hooks dependency array functional components memoization render props side effects useContext useEffect useReducer useState

Stored enrichment (catalog DB)

Category
Concept
Sub-category
React Hooks
Vendor
Facebook
License
mit
Year introduced
2019
Confidence
0.95
Version strategy
NOT_APPLICABLE

Maturity reasoning: React Hooks are a standard React skill in modern JDs and docs; since React 16.8 they replaced class-based state/lifecycle patterns in most new codebases, with broad hiring demand across frontend roles.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • React Component Architecture Catalog dimension db id 302

    Library dimension (catalog)

    Roles linked in library: React Frontend Developer

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
React Component Architecture
react-component-architecture
Skipped — no persistable v3 meta for new skill
skill_not_in_db_v3_proposed
JSON API Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: JSON:API id=3129 · json-api

Aliases — catalog

  • JSON:API (CANONICAL) primary

Context tags (catalog)

HTTP status codes content negotiation deserialization error handling filtering links media types meta pagination relationships request format resource identifiers response format serialization sorting

Stored enrichment (catalog DB)

Category
Protocol
Sub-category
Api Protocol
Vendor
JSON:API
License
other_open
Year introduced
2013
Confidence
0.90
Version strategy
NOT_APPLICABLE

Maturity reasoning: JSON:API appears in some API design JDs and library ecosystems, but JD volume is far below REST/GraphQL and it lacks broad platform-native adoption; market signal is limited, specialized usage.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • External System Integrations Catalog dimension db id 14

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
External System Integrations
external-system-integrations
Skipped — no persistable v3 meta for new skill
skill_not_in_db_v3_proposed
Metro Bundler Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: Metro bundler id=1068 · metro-bundler

Aliases — catalog

  • Metro bundler (CANONICAL) primary

Context tags (catalog)

Android Asset Management Babel Bundle Size CLI Development Server ES6 Hot Reloading JavaScript Metro.config.js React Native Webpack Yarn iOS npm

Stored enrichment (catalog DB)

Category
Tool
Sub-category
Javascript Bundler
Vendor
Facebook
License
mit
Year introduced
2015
Confidence
0.96
Version strategy
NOT_APPLICABLE

Maturity reasoning: Metro bundler appears mainly in React Native job posts and docs, with far lower JD volume than Webpack/Vite; it’s a specialized default for one ecosystem rather than a broad hiring staple.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • Build and Release Tooling Catalog dimension db id 89

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
Build and Release Tooling
build-and-release-tooling
Existing dimension (library) · Role↔dimension saved
AR libraries Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Software Libraries
Sub-category
general
Skill nature
TOOL
Volatility
FAST
Typical lifespan
SHORT_LIVED
Version strategy
VERSIONED
Reanimated Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Web Frameworks
Sub-category
Animation
Skill nature
TOOL
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED
Styled Components Secondary Library skill API 3: existing canonical (in_db) Existing skill (matched library)
Canonical: styled-components id=2525 · styled-components

Aliases — catalog

  • styled-components (CANONICAL) primary

Context tags (catalog)

CSS modules CSS-in-JS JavaScript React component libraries dynamic styling global styles props responsive design server-side rendering styled system styled-components v5 styled-components/native themable theme provider

Stored enrichment (catalog DB)

Category
Library
Sub-category
Css In Js Library
Vendor
Styled Components
License
mit
Year introduced
2016
Confidence
0.98
Version strategy
NOT_APPLICABLE

Maturity reasoning: Commonly listed in frontend JDs and widely used in React codebases; GitHub/npm usage remains substantial, though many teams now also mention alternatives like Emotion or CSS Modules.

Skill profile (library / DB)

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

Dimensions (API 2 worklist)

  • CSS Architecture and Styling Catalog dimension db id 117

    Library dimension (catalog)

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

API 3 link attempts (this skill)

Dimension Skill↔dim Role↔dim Outcome
CSS Architecture and Styling
css-architecture-and-styling
Skipped — no persistable v3 meta for new skill
skill_not_in_db_v3_proposed
Store normalization Secondary New / orchestrated API 3: new canonical path (new) New / unmatched skill (orchestrated in API 2)

Skill enrichment (orchestrator / LLM)

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

Derived legacy fields
Category
Concepts
Sub-category
general
Skill nature
CONCEPT
Volatility
MEDIUM
Typical lifespan
MULTI_YEAR
Version strategy
UNVERSIONED

All API 3 persistence rows

Same grid as the skill-extractor “Persistence items” table: one row per (skill × dimension) work item.

Skill Tag Dimension Skill↔dim Role↔dim Outcome Notes
TypeScript in_db
Cross-Platform App Languages
cross-platform-app-languages
Existing dimension (library) · Role↔dimension saved
TypeScript in_db
JavaScript and TypeScript
javascript-and-typescript
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TypeScript in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TypeScript in_db
Programming Languages for XR
programming-languages-for-xr
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
TypeScript in_db
Sitecore Development Languages
sitecore-development-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Native in_db
Cross-Platform Mobile UI Frameworks
cross-platform-mobile-ui-frameworks
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Native in_db
UI Frameworks and Rendering
ui-frameworks-and-rendering
Existing dimension (library) · Role↔dimension saved
Swift in_db
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Swift in_db
Swift and Objective-C
swift-and-objective-c
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin in_db
Java Language and JVM
java-language-and-jvm
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin in_db
Kotlin and Java
kotlin-and-java
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin in_db
Native Mobile Languages
native-mobile-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Kotlin in_db
Programming Languages
programming-languages
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Testing Library in_db
Frontend Testing and E2E Automation
frontend-testing-and-e2e-automation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Jest in_db
Frontend Testing and E2E Automation
frontend-testing-and-e2e-automation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Jest in_db
Mobile Testing Frameworks
mobile-testing-frameworks
Existing dimension (library) · Role↔dimension saved
Jest in_db
Testing and Integration Validation
testing-and-integration-validation
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Detox in_db
Mobile Testing Frameworks
mobile-testing-frameworks
Existing dimension (library) · Role↔dimension saved
Git in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GitHub in_db
CI/CD Pipeline Platforms
ci-cd-pipeline-platforms
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
GitHub in_db
CI/CD for Machine Learning
ci-cd-for-machine-learning
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Scrum in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Scrum in_db
Software Concepts, Patterns & Practices
software-concepts-patterns-practices
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Code Review in_db
React Frontend Development
d_init_01
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Redux in_db
Screen Navigation and State
screen-navigation-and-state
Existing dimension (library) · Role↔dimension saved
Redux in_db
State Management Patterns
state-management-patterns
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
Redux Toolkit in_db
State Management Patterns
state-management-patterns
Existing dimension (library) · Role↔dimension skipped (dimension not under chosen role)
React Hook Form new
React Component Architecture
react-component-architecture
Skipped — no persistable v3 meta for new skill skill_not_in_db_v3_proposed
JSON API new
External System Integrations
external-system-integrations
Skipped — no persistable v3 meta for new skill skill_not_in_db_v3_proposed
Metro Bundler in_db
Build and Release Tooling
build-and-release-tooling
Existing dimension (library) · Role↔dimension saved
Styled Components new
CSS Architecture and Styling
css-architecture-and-styling
Skipped — no persistable v3 meta for new skill skill_not_in_db_v3_proposed

Library artifacts (this run)

Kind Detail DB id
canonical_skill_proposed Gitflow | type=Practices subtype=general nature=PRACTICE lifespan=MULTI_YEAR
canonical_skill_proposed Redux-Logic | type=Web Frameworks subtype=State Management nature=TOOL lifespan=SHORT_LIVED
canonical_skill_proposed Redux-Saga | type=Web Frameworks subtype=State Management nature=TOOL lifespan=SHORT_LIVED
canonical_skill_proposed Formik | type=Web Frameworks subtype=Forms nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed AR libraries | type=Software Libraries subtype=general nature=TOOL lifespan=SHORT_LIVED
canonical_skill_proposed Reanimated | type=Web Frameworks subtype=Animation nature=TOOL lifespan=MULTI_YEAR
canonical_skill_proposed Store normalization | type=Concepts subtype=general nature=CONCEPT lifespan=MULTI_YEAR
dimension_skill_link_proposed React Hook Form ↔ React Component Architecture
dimension_skill_link_proposed JSON API ↔ External System Integrations
dimension_skill_link_proposed Styled Components ↔ CSS Architecture and Styling
nano JD Parser — gpt-4.1-nano click to toggle
Experienceat least 5 years
DomainOther
JD type pass
Show raw JSON
{
  "JD_type": "pass",
  "about_company": null,
  "certifications": [],
  "company_name": null,
  "ctc": null,
  "domain": {
    "primary": {
      "aliases": [],
      "domain": "Other"
    },
    "secondary": null
  },
  "education": [],
  "experience": {
    "max": null,
    "min": 5,
    "raw": "at least 5 years"
  },
  "job_locations": [],
  "role": null,
  "role_aliases": [],
  "role_archetype": "Engineering",
  "roles_and_responsibilities": [
    {
      "bullet_count": 12,
      "heading": "Responsibilities",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Development and ongoing maintenance of",
        "last_5_words": "Sprint Review, and Retrospective."
      },
      "text": "- Development and ongoing maintenance of mobile applications built with TypeScript using React Native and fundamental approaches of native development (Swift/Kotlin);\n- Creating solutions and algorithms in accordance with technical specifications or other required documentation;\n- Writing program code following the prescribed application architecture;\n- Analyzing and refactoring code using design patterns and established standards;\n- Writing unit tests (React-testing-library, Jest, Detox as a plus);\n- Identifying code smells and performing refactoring using design patterns and accepted standards;\n- Estimating tasks and working to meet deadlines, providing timely updates if rescheduling or deadline adjustments are necessary;\n- Designing, developing, and maintaining client-side mobile applications;\n- Participating in the Code Review process and offering constructive feedback on code developed by other developers;\n- Collaborating with teammates to provide guidance on patterns and behaviors employed in the web/mobile platform;\n- Employing Git and GitHub to manage code in accordance with Gitflow standards;\n- Taking part in team Scrum activities such as Refinement, Estimation, Grooming, Sprint Planning, Daily Standup, Sprint Review, and Retrospective.",
      "word_count": 203
    },
    {
      "bullet_count": 18,
      "heading": "Requirements",
      "heading_was_present": true,
      "source_marker": {
        "first_5_words": "Strong proficiency and substantial hands-on",
        "last_5_words": "normalization techniques."
      },
      "text": "- Strong proficiency and substantial hands-on experience with React Native at least 5 years;\n- Knowledge and practice experience with Basic Swift/Kotlin;\n- Proven capability in utilizing Typescript effectively to craft robust and scalable mobile applications;\n- Knowledge of Redux and Redux Toolkit;\n- Hands-on exposure to Redux-Logic and Redux-Saga;\n- Practical experience utilizing React Testing Library to ensure the robustness of codebase;\n- Experience leveraging Formik and React Hook Form;\n- Experience working with Jest;\n- Practical experience with JSON API, working with data interchange formats;\n- Experience utilizing Git and adhering to Gitflow practices;\n- Familiarity with Metro Bundler;\n- English language proficiency at the Intermediate level or higher.\n- Experience with Detox for testing;\n- Experience with AR libraries;\n- Experience with Reanimated for animations;\n- Experience with Getting apps out into the world with publishing experience;\n- Experience with Styled Components;\n- Experience with Store normalization techniques.",
      "word_count": 218
    }
  ],
  "urls": []
}
API 1 — extract-from-jd click to toggle
{
  "final_skills": [
    {
      "is_primary": true,
      "skill_name": "TypeScript"
    },
    {
      "is_primary": true,
      "skill_name": "React Native"
    },
    {
      "is_primary": true,
      "skill_name": "Swift"
    },
    {
      "is_primary": true,
      "skill_name": "Kotlin"
    },
    {
      "is_primary": true,
      "skill_name": "React Testing Library"
    },
    {
      "is_primary": true,
      "skill_name": "Jest"
    },
    {
      "is_primary": false,
      "skill_name": "Detox"
    },
    {
      "is_primary": true,
      "skill_name": "Git"
    },
    {
      "is_primary": true,
      "skill_name": "GitHub"
    },
    {
      "is_primary": true,
      "skill_name": "Gitflow"
    },
    {
      "is_primary": false,
      "skill_name": "Scrum"
    },
    {
      "is_primary": false,
      "skill_name": "Code Review"
    },
    {
      "is_primary": true,
      "skill_name": "Redux"
    },
    {
      "is_primary": true,
      "skill_name": "Redux Toolkit"
    },
    {
      "is_primary": false,
      "skill_name": "Redux-Logic"
    },
    {
      "is_primary": false,
      "skill_name": "Redux-Saga"
    },
    {
      "is_primary": false,
      "skill_name": "Formik"
    },
    {
      "is_primary": false,
      "skill_name": "React Hook Form"
    },
    {
      "is_primary": false,
      "skill_name": "JSON API"
    },
    {
      "is_primary": false,
      "skill_name": "Metro Bundler"
    },
    {
      "is_primary": false,
      "skill_name": "AR libraries"
    },
    {
      "is_primary": false,
      "skill_name": "Reanimated"
    },
    {
      "is_primary": false,
      "skill_name": "Styled Components"
    },
    {
      "is_primary": false,
      "skill_name": "Store normalization"
    }
  ],
  "jd_role": null,
  "nano_parsed": {
    "JD_type": "pass",
    "about_company": null,
    "certifications": [],
    "company_name": null,
    "ctc": null,
    "domain": {
      "primary": {
        "aliases": [],
        "domain": "Other"
      },
      "secondary": null
    },
    "education": [],
    "experience": {
      "max": null,
      "min": 5,
      "raw": "at least 5 years"
    },
    "job_locations": [],
    "role": null,
    "role_aliases": [],
    "role_archetype": "Engineering",
    "roles_and_responsibilities": [
      {
        "bullet_count": 12,
        "heading": "Responsibilities",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Development and ongoing maintenance of",
          "last_5_words": "Sprint Review, and Retrospective."
        },
        "text": "- Development and ongoing maintenance of mobile applications built with TypeScript using React Native and fundamental approaches of native development (Swift/Kotlin);\n- Creating solutions and algorithms in accordance with technical specifications or other required documentation;\n- Writing program code following the prescribed application architecture;\n- Analyzing and refactoring code using design patterns and established standards;\n- Writing unit tests (React-testing-library, Jest, Detox as a plus);\n- Identifying code smells and performing refactoring using design patterns and accepted standards;\n- Estimating tasks and working to meet deadlines, providing timely updates if rescheduling or deadline adjustments are necessary;\n- Designing, developing, and maintaining client-side mobile applications;\n- Participating in the Code Review process and offering constructive feedback on code developed by other developers;\n- Collaborating with teammates to provide guidance on patterns and behaviors employed in the web/mobile platform;\n- Employing Git and GitHub to manage code in accordance with Gitflow standards;\n- Taking part in team Scrum activities such as Refinement, Estimation, Grooming, Sprint Planning, Daily Standup, Sprint Review, and Retrospective.",
        "word_count": 203
      },
      {
        "bullet_count": 18,
        "heading": "Requirements",
        "heading_was_present": true,
        "source_marker": {
          "first_5_words": "Strong proficiency and substantial hands-on",
          "last_5_words": "normalization techniques."
        },
        "text": "- Strong proficiency and substantial hands-on experience with React Native at least 5 years;\n- Knowledge and practice experience with Basic Swift/Kotlin;\n- Proven capability in utilizing Typescript effectively to craft robust and scalable mobile applications;\n- Knowledge of Redux and Redux Toolkit;\n- Hands-on exposure to Redux-Logic and Redux-Saga;\n- Practical experience utilizing React Testing Library to ensure the robustness of codebase;\n- Experience leveraging Formik and React Hook Form;\n- Experience working with Jest;\n- Practical experience with JSON API, working with data interchange formats;\n- Experience utilizing Git and adhering to Gitflow practices;\n- Familiarity with Metro Bundler;\n- English language proficiency at the Intermediate level or higher.\n- Experience with Detox for testing;\n- Experience with AR libraries;\n- Experience with Reanimated for animations;\n- Experience with Getting apps out into the world with publishing experience;\n- Experience with Styled Components;\n- Experience with Store normalization techniques.",
        "word_count": 218
      }
    ],
    "urls": []
  },
  "rejected": false,
  "rejection_reason": null,
  "run_id": "e72afe83-94db-4905-a448-89e895aef164",
  "stage3_signals": {
    "alias_found": false,
    "alias_match_roles": [],
    "kra_match_roles": [
      {
        "display_name": "Node.js Backend Developer",
        "kra_matches": [
          {
            "kra_text": "code review and refactoring",
            "sentence": "Identifying code smells and performing refactoring using design patterns and accepted standards;",
            "similarity": 0.6744
          },
          {
            "kra_text": "code review and refactoring",
            "sentence": "Analyzing and refactoring code using design patterns and established standards;",
            "similarity": 0.6114
          },
          {
            "kra_text": "code review and refactoring",
            "sentence": "Participating in the Code Review process and offering constructive feedback on code developed by other developers;",
            "similarity": 0.561
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 82,
        "score": 0.6156,
        "slug": "node-backend-developer",
        "total_count": null
      },
      {
        "display_name": "Angular Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "code review and refactoring",
            "sentence": "Identifying code smells and performing refactoring using design patterns and accepted standards;",
            "similarity": 0.6743
          },
          {
            "kra_text": "code review and refactoring",
            "sentence": "Analyzing and refactoring code using design patterns and established standards;",
            "similarity": 0.6114
          },
          {
            "kra_text": "code review and refactoring",
            "sentence": "Participating in the Code Review process and offering constructive feedback on code developed by other developers;",
            "similarity": 0.561
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 90,
        "score": 0.6156,
        "slug": "angular-frontend-developer",
        "total_count": null
      },
      {
        "display_name": "Frontend Developer",
        "kra_matches": [
          {
            "kra_text": "Collaborates with UX designers to refine interaction details, animations, responsive breakpoints, and micro-interaction behavior.",
            "sentence": "Collaborating with teammates to provide guidance on patterns and behaviors employed in the web/mobile platform;",
            "similarity": 0.6278
          },
          {
            "kra_text": "Builds responsive user interfaces and interactive web components using React, Vue, or Angular with TypeScript, HTML5, and modern CSS for browser-based applications.",
            "sentence": "Development and ongoing maintenance of mobile applications built with TypeScript using React Native and fundamental approaches of native development (Swift/Kotlin);",
            "similarity": 0.5513
          },
          {
            "kra_text": "Builds responsive user interfaces and interactive web components using React, Vue, or Angular with TypeScript, HTML5, and modern CSS for browser-based applications.",
            "sentence": "Proven capability in utilizing Typescript effectively to craft robust and scalable mobile applications;",
            "similarity": 0.5313
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 7,
        "score": 0.5701,
        "slug": "frontend-engineer",
        "total_count": null
      },
      {
        "display_name": "Go Backend Developer",
        "kra_matches": [
          {
            "kra_text": "code review and testing support",
            "sentence": "Participating in the Code Review process and offering constructive feedback on code developed by other developers;",
            "similarity": 0.5992
          },
          {
            "kra_text": "backend refactoring and modularization",
            "sentence": "Identifying code smells and performing refactoring using design patterns and accepted standards;",
            "similarity": 0.5675
          },
          {
            "kra_text": "backend refactoring and modularization",
            "sentence": "Analyzing and refactoring code using design patterns and established standards;",
            "similarity": 0.5331
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 81,
        "score": 0.5666,
        "slug": "go-backend-developer",
        "total_count": null
      },
      {
        "display_name": "Ruby Backend Developer",
        "kra_matches": [
          {
            "kra_text": "refactoring and code organization",
            "sentence": "Identifying code smells and performing refactoring using design patterns and accepted standards;",
            "similarity": 0.6329
          },
          {
            "kra_text": "refactoring and code organization",
            "sentence": "Analyzing and refactoring code using design patterns and established standards;",
            "similarity": 0.586
          },
          {
            "kra_text": "Server-side feature implementation",
            "sentence": "Designing, developing, and maintaining client-side mobile applications;",
            "similarity": 0.4523
          }
        ],
        "matched_count": null,
        "matched_skills": null,
        "role_id": 85,
        "score": 0.5571,
        "slug": "ruby-backend-developer",
        "total_count": null
      }
    ],
    "skill_match_roles": [
      {
        "display_name": "Frontend Developer",
        "kra_matches": null,
        "matched_count": 6,
        "matched_skills": [
          "Jest",
          "React Native",
          "React Testing Library",
          "Redux",
          "Redux Toolkit",
          "TypeScript"
        ],
        "role_id": 7,
        "score": 0.5455,
        "slug": "frontend-engineer",
        "total_count": 11
      },
      {
        "display_name": "Fullstack Developer",
        "kra_matches": null,
        "matched_count": 5,
        "matched_skills": [
          "Jest",
          "Kotlin",
          "React Native",
          "Redux",
          "TypeScript"
        ],
        "role_id": 15,
        "score": 0.4545,
        "slug": "full-stack-engineer",
        "total_count": 11
      },
      {
        "display_name": "Angular Frontend Developer",
        "kra_matches": null,
        "matched_count": 5,
        "matched_skills": [
          "Jest",
          "React Testing Library",
          "Redux",
          "Redux Toolkit",
          "TypeScript"
        ],
        "role_id": 90,
        "score": 0.4545,
        "slug": "angular-frontend-developer",
        "total_count": 11
      },
      {
        "display_name": "React Frontend Developer",
        "kra_matches": null,
        "matched_count": 5,
        "matched_skills": [
          "Jest",
          "React Testing Library",
          "Redux",
          "Redux Toolkit",
          "TypeScript"
        ],
        "role_id": 89,
        "score": 0.4545,
        "slug": "react-frontend-developer",
        "total_count": 11
      },
      {
        "display_name": "Web Developer",
        "kra_matches": null,
        "matched_count": 4,
        "matched_skills": [
          "Jest",
          "React Native",
          "React Testing Library",
          "TypeScript"
        ],
        "role_id": 25,
        "score": 0.3636,
        "slug": "web-developer",
        "total_count": 11
      }
    ]
  },
  "stage4_decision": {
    "alias_collision_detected": false,
    "case": "DOMAIN",
    "chosen_role": {
      "display_name": "Hybrid Mobile Developer",
      "kra_matches": null,
      "matched_count": null,
      "matched_skills": null,
      "role_id": 11,
      "score": 0.99,
      "slug": "hybrid-mobile-developer",
      "total_count": null
    },
    "confidence": 0.99,
    "is_new_role": false,
    "llm2_fired": false,
    "llm2_reasoning": null,
    "matched_dimensions": [
      "Mobile App Development",
      "Client-side Mobile Application Engineering",
      "Cross-platform Mobile Development",
      "Unit and End-to-End Testing",
      "State Management and Data Normalization",
      "Code Review and Refactoring",
      "Agile Scrum Collaboration",
      "App Publishing and Release Management"
    ],
    "matched_kras": [
      "Development and ongoing maintenance of mobile applications",
      "Creating solutions and algorithms in accordance with technical specifications",
      "Writing program code following the prescribed application architecture",
      "Analyzing and refactoring code using design patterns",
      "Writing unit tests",
      "Identifying code smells and performing refactoring",
      "Estimating tasks and working to meet deadlines",
      "Participating in the Code Review process",
      "Collaborating with teammates to provide guidance",
      "Taking part in team Scrum activities"
    ],
    "matched_skills": [
      "TypeScript",
      "React Native",
      "Swift",
      "Kotlin",
      "React-testing-library",
      "Jest",
      "Detox",
      "Redux",
      "Redux Toolkit",
      "Redux-Logic",
      "Redux-Saga",
      "Formik",
      "React Hook Form",
      "JSON API",
      "Git",
      "GitHub",
      "Gitflow",
      "Metro Bundler",
      "AR libraries",
      "Reanimated"
    ],
    "new_role_display_name": null,
    "new_role_slug": null,
    "queued": false,
    "reasoning": "Domain=Software Engineering \u2192 sub-role react-native-developer; The JD is centered on React Native mobile app development with TypeScript and related mobile testing, state management, and publishing workflows, which best matches Hybrid Mobile Developer.",
    "sub_role": {
      "confidence": 0.99,
      "display_name": "React Native Developer",
      "reasoning": "React Native, TypeScript, Metro Bundler, Redux, Jest, and Detox are explicitly central, with only minor Swift/Kotlin support mentioned.",
      "role_id": 73,
      "slug": "react-native-developer"
    }
  },
  "stage5_updates": {
    "centroid_n_after": 69,
    "centroid_updated": true,
    "collision_log_id": null,
    "new_kra_attached": {
      "best_kra_similarity": 0.0,
      "queue_id": 1488,
      "r_and_r_preview": "- Development and ongoing maintenance of mobile applications built with TypeScript using React Native and fundamental approaches of native development (Swift/Kotlin);\n- Creating solutions and algorith",
      "role_display_name": "Hybrid Mobile Developer",
      "role_slug": "hybrid-mobile-developer",
      "status": "pending"
    },
    "new_skills_attached": [
      {
        "is_primary": true,
        "queue_id": 20000,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "Gitflow",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 20002,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "Redux-Logic",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 20004,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "Redux-Saga",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 20005,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "Formik",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 20006,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "React Hook Form",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 20007,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "JSON API",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 20008,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "AR libraries",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 20009,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "Reanimated",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 20010,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "Styled Components",
        "status": "pending"
      },
      {
        "is_primary": false,
        "queue_id": 20011,
        "role_display_name": "Hybrid Mobile Developer",
        "role_slug": "hybrid-mobile-developer",
        "skill_name": "Store normalization",
        "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": 914,
      "existing_alias_text": "TypeScript",
      "input_term": "TypeScript",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "TypeScript",
        "id": 524,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "typescript",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1657,
      "existing_alias_text": "React Native",
      "input_term": "React Native",
      "matched_canonical": {
        "category_id": 5,
        "display_name": "React Native",
        "id": 1040,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react-native",
        "sub_category_id": 2146,
        "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": 756,
      "existing_alias_text": "Swift",
      "input_term": "Swift",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Swift",
        "id": 440,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "swift",
        "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": 24,
      "existing_alias_text": "Kotlin",
      "input_term": "Kotlin",
      "matched_canonical": {
        "category_id": 6,
        "display_name": "Kotlin",
        "id": 2,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "kotlin",
        "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": 3924,
      "existing_alias_text": "React Testing Library",
      "input_term": "React Testing Library",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "React Testing Library",
        "id": 2548,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "react-testing-library",
        "sub_category_id": 491,
        "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": 1156,
      "existing_alias_text": "Jest",
      "input_term": "Jest",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Jest",
        "id": 651,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "jest",
        "sub_category_id": 513,
        "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": 1687,
      "existing_alias_text": "Detox",
      "input_term": "Detox",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Detox",
        "id": 1061,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "detox",
        "sub_category_id": 799,
        "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": 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": 3627,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 864,
      "existing_alias_text": "Code Review",
      "input_term": "Code Review",
      "matched_canonical": {
        "category_id": 58,
        "display_name": "Code Review",
        "id": 516,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PRACTICE",
        "slug": "code-review",
        "sub_category_id": 364,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "alias"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1101,
      "existing_alias_text": "Redux",
      "input_term": "Redux",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "Redux",
        "id": 617,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "redux",
        "sub_category_id": 490,
        "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": 3859,
      "existing_alias_text": "Redux Toolkit",
      "input_term": "Redux Toolkit",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "Redux Toolkit",
        "id": 2519,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "redux-toolkit",
        "sub_category_id": 490,
        "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": 3970,
      "existing_alias_text": "React Hooks",
      "input_term": "React Hook Form",
      "matched_canonical": {
        "category_id": 2,
        "display_name": "React Hooks",
        "id": 2594,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "react-hooks",
        "sub_category_id": 1902,
        "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": null,
      "existing_alias_text": null,
      "input_term": "JSON API",
      "matched_canonical": {
        "category_id": 10,
        "display_name": "JSON:API",
        "id": 3129,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "json-api",
        "sub_category_id": 2347,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "embedding_display_name"
    },
    {
      "alias_persist_skipped_reason": "alias_text already exists for this canonical skill",
      "alias_persisted": false,
      "existing_alias_id": 1694,
      "existing_alias_text": "Metro bundler",
      "input_term": "Metro Bundler",
      "matched_canonical": {
        "category_id": 13,
        "display_name": "Metro bundler",
        "id": 1068,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "metro-bundler",
        "sub_category_id": 797,
        "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": 3865,
      "existing_alias_text": "styled-components",
      "input_term": "Styled Components",
      "matched_canonical": {
        "category_id": 7,
        "display_name": "styled-components",
        "id": 2525,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "styled-components",
        "sub_category_id": 1920,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "matched_via": "embedding_alias"
    }
  ],
  "candidate_roles": [
    {
      "display_name": "Hybrid Mobile Developer",
      "id": 11,
      "rationale": null,
      "role_archetype": null,
      "slug": "hybrid-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "Angular Frontend Developer",
      "id": 90,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "angular-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Frontend Developer",
      "id": 7,
      "rationale": null,
      "role_archetype": null,
      "slug": "frontend-engineer",
      "source": "db"
    },
    {
      "display_name": "Ionic Developer",
      "id": 434,
      "rationale": null,
      "role_archetype": null,
      "slug": "ionic-developer",
      "source": "db"
    },
    {
      "display_name": "Node.js Backend Developer",
      "id": 82,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "node-backend-developer",
      "source": "db"
    },
    {
      "display_name": "React Frontend Developer",
      "id": 89,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "react-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "React Native Developer",
      "id": 73,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "react-native-developer",
      "source": "db"
    },
    {
      "display_name": "Svelte Frontend Developer",
      "id": 92,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "svelte-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Vue Frontend Developer",
      "id": 91,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "vue-frontend-developer",
      "source": "db"
    },
    {
      "display_name": "Web Developer",
      "id": 25,
      "rationale": null,
      "role_archetype": null,
      "slug": "web-developer",
      "source": "db"
    },
    {
      "display_name": "Backend Developer",
      "id": 1,
      "rationale": null,
      "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
      "slug": "backend-engineer",
      "source": "db"
    },
    {
      "display_name": "Fullstack Developer",
      "id": 435,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "fullstack-developer",
      "source": "db"
    },
    {
      "display_name": "Fullstack Developer",
      "id": 15,
      "rationale": null,
      "role_archetype": null,
      "slug": "full-stack-engineer",
      "source": "db"
    },
    {
      "display_name": "AR/VR Engineer",
      "id": 8,
      "rationale": null,
      "role_archetype": null,
      "slug": "ar-vr-engineer",
      "source": "db"
    },
    {
      "display_name": "Sitecore Dev",
      "id": 233,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "sitecore-dev",
      "source": "db"
    },
    {
      "display_name": "Native Mobile Developer",
      "id": 75,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "native-mobile-developer",
      "source": "db"
    },
    {
      "display_name": "iOS Developer",
      "id": 6,
      "rationale": null,
      "role_archetype": null,
      "slug": "ios-engineer",
      "source": "db"
    },
    {
      "display_name": "Java Backend Developer",
      "id": 79,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "java-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Kotlin Backend Developer",
      "id": 84,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "kotlin-server-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Scala Backend Developer",
      "id": 87,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "scala-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Android Developer",
      "id": 4,
      "rationale": null,
      "role_archetype": null,
      "slug": "android-engineer",
      "source": "db"
    },
    {
      "display_name": "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": "Engineering Manager",
      "id": 121,
      "rationale": null,
      "role_archetype": null,
      "slug": "engineering-manager",
      "source": "db"
    },
    {
      "display_name": "Flutter Developer",
      "id": 74,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "flutter-developer",
      "source": "db"
    },
    {
      "display_name": ".NET Backend Developer",
      "id": 83,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "dotnet-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Drupal Dev",
      "id": 228,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "drupal-dev",
      "source": "db"
    },
    {
      "display_name": "PHP Backend Developer",
      "id": 86,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "php-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Python Backend Developer",
      "id": 80,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "python-backend-developer",
      "source": "db"
    },
    {
      "display_name": "Ruby Backend Developer",
      "id": 85,
      "rationale": null,
      "role_archetype": "Engineering",
      "slug": "ruby-backend-developer",
      "source": "db"
    }
  ],
  "chosen_role": {
    "display_name": "Hybrid Mobile Developer",
    "id": 11,
    "rationale": "Domain=Software Engineering \u2192 sub-role react-native-developer; The JD is centered on React Native mobile app development with TypeScript and related mobile testing, state management, and publishing workflows, which best matches Hybrid Mobile Developer.",
    "role_archetype": null,
    "slug": "hybrid-mobile-developer",
    "source": "db"
  },
  "dimensions": [
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform App Languages",
        "id": 167,
        "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
        "slug": "cross-platform-app-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "JavaScript and TypeScript",
        "id": 114,
        "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
        "slug": "javascript-and-typescript",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages",
        "id": 1,
        "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
        "slug": "programming-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Programming Languages for XR",
        "id": 97,
        "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
        "slug": "programming-languages-for-xr",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "AR/VR Engineer",
          "id": 8,
          "rationale": null,
          "role_archetype": null,
          "slug": "ar-vr-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Sitecore Development Languages",
        "id": 438,
        "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
        "slug": "sitecore-development-languages",
        "source": "db"
      },
      "input_skill": "TypeScript",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Sitecore Dev",
          "id": 233,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "sitecore-dev",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Cross-Platform Mobile UI Frameworks",
        "id": 319,
        "rationale": "Frameworks, rendering models, and component libraries used to build shared mobile screens, layouts, and interactive experiences across platforms. This includes React Native and related tooling such as React Native CLI and Expo, as well as cross-platform UI libraries and interaction patterns like React Native Paper, NativeBase, gesture handlers, and animated components; it also covers comparable hybrid mobile UI frameworks such as Flutter. Excludes browser-only frontend frameworks and native platform UI toolkits such as SwiftUI, UIKit, Jetpack Compose, and Android Views.",
        "slug": "cross-platform-mobile-ui-frameworks",
        "source": "db"
      },
      "input_skill": "React Native",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "UI Frameworks and Rendering",
        "id": 115,
        "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
        "slug": "ui-frameworks-and-rendering",
        "source": "db"
      },
      "input_skill": "React Native",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Languages",
        "id": 274,
        "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
        "slug": "native-mobile-languages",
        "source": "db"
      },
      "input_skill": "Swift",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Swift and Objective-C",
        "id": 81,
        "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
        "slug": "swift-and-objective-c",
        "source": "db"
      },
      "input_skill": "Swift",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "iOS Developer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Java Language and JVM",
        "id": 279,
        "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
        "slug": "java-language-and-jvm",
        "source": "db"
      },
      "input_skill": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Kotlin and Java",
        "id": 161,
        "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
        "slug": "kotlin-and-java",
        "source": "db"
      },
      "input_skill": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Native Mobile Languages",
        "id": 274,
        "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
        "slug": "native-mobile-languages",
        "source": "db"
      },
      "input_skill": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "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": "Kotlin",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "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": "React Testing Library",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "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": "Jest",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Mobile Testing Frameworks",
        "id": 168,
        "rationale": "Test tools and patterns used to validate shared mobile UI, integration, and device behavior. Hybrid developers rely on these to catch regressions in screen flows, state transitions, and platform-specific edge cases.",
        "slug": "mobile-testing-frameworks",
        "source": "db"
      },
      "input_skill": "Jest",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Testing and Integration Validation",
        "id": 217,
        "rationale": "Automated checks used to verify feature behavior across client, server, and data boundaries. Full stack engineers rely on this to catch regressions in end-to-end flows and integration points.",
        "slug": "testing-and-integration-validation",
        "source": "db"
      },
      "input_skill": "Jest",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Mobile Testing Frameworks",
        "id": 168,
        "rationale": "Test tools and patterns used to validate shared mobile UI, integration, and device behavior. Hybrid developers rely on these to catch regressions in screen flows, state transitions, and platform-specific edge cases.",
        "slug": "mobile-testing-frameworks",
        "source": "db"
      },
      "input_skill": "Detox",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        }
      ]
    },
    {
      "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": "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": "Software Concepts, Patterns \u0026 Practices",
        "id": 478,
        "rationale": "Champion foundational software design patterns, development methodologies, and engineering best practices.",
        "slug": "software-concepts-patterns-practices",
        "source": "db"
      },
      "input_skill": "Scrum",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Engineering Manager",
          "id": 121,
          "rationale": null,
          "role_archetype": null,
          "slug": "engineering-manager",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Frontend Development",
        "id": 96,
        "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
        "slug": "d_init_01",
        "source": "db"
      },
      "input_skill": "Code Review",
      "llm_role": null,
      "roles_from_db": []
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "Screen Navigation and State",
        "id": 83,
        "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
        "slug": "screen-navigation-and-state",
        "source": "db"
      },
      "input_skill": "Redux",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Flutter Developer",
          "id": 74,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "flutter-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "Native Mobile Developer",
          "id": 75,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "native-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "React Native Developer",
          "id": 73,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-native-developer",
          "source": "db"
        },
        {
          "display_name": "iOS Developer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "State Management Patterns",
        "id": 116,
        "rationale": "Client-side state organization for forms, UI interactions, cached data, and cross-component coordination. This cluster is coherent because frontend work often hinges on predictable state transitions and data flow.",
        "slug": "state-management-patterns",
        "source": "db"
      },
      "input_skill": "Redux",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Flutter Developer",
          "id": 74,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "flutter-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "State Management Patterns",
        "id": 116,
        "rationale": "Client-side state organization for forms, UI interactions, cached data, and cross-component coordination. This cluster is coherent because frontend work often hinges on predictable state transitions and data flow.",
        "slug": "state-management-patterns",
        "source": "db"
      },
      "input_skill": "Redux Toolkit",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Angular Frontend Developer",
          "id": 90,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "angular-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Flutter Developer",
          "id": 74,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "flutter-developer",
          "source": "db"
        },
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Ionic Developer",
          "id": 434,
          "rationale": null,
          "role_archetype": null,
          "slug": "ionic-developer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "React Component Architecture",
        "id": 302,
        "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
        "slug": "react-component-architecture",
        "source": "db"
      },
      "input_skill": "React Hook Form",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "External System Integrations",
        "id": 14,
        "rationale": "Connecting backend services to third-party APIs and internal enterprise systems. This includes client libraries, webhooks, retries, data mapping, and integration failure handling.",
        "slug": "external-system-integrations",
        "source": "db"
      },
      "input_skill": "JSON API",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": ".NET Backend Developer",
          "id": 83,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "dotnet-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Backend Developer",
          "id": 1,
          "rationale": null,
          "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
          "slug": "backend-engineer",
          "source": "db"
        },
        {
          "display_name": "Drupal Dev",
          "id": 228,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "drupal-dev",
          "source": "db"
        },
        {
          "display_name": "Java Backend Developer",
          "id": 79,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "java-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Kotlin Backend Developer",
          "id": 84,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "kotlin-server-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Node.js Backend Developer",
          "id": 82,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "node-backend-developer",
          "source": "db"
        },
        {
          "display_name": "PHP Backend Developer",
          "id": 86,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "php-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Python Backend Developer",
          "id": 80,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "python-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Ruby Backend Developer",
          "id": 85,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "ruby-backend-developer",
          "source": "db"
        },
        {
          "display_name": "Scala Backend Developer",
          "id": 87,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "scala-backend-developer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "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": "Metro Bundler",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Android Developer",
          "id": 4,
          "rationale": null,
          "role_archetype": null,
          "slug": "android-engineer",
          "source": "db"
        },
        {
          "display_name": "Flutter Developer",
          "id": 74,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "flutter-developer",
          "source": "db"
        },
        {
          "display_name": "Hybrid Mobile Developer",
          "id": 11,
          "rationale": null,
          "role_archetype": null,
          "slug": "hybrid-mobile-developer",
          "source": "db"
        },
        {
          "display_name": "iOS Developer",
          "id": 6,
          "rationale": null,
          "role_archetype": null,
          "slug": "ios-engineer",
          "source": "db"
        }
      ]
    },
    {
      "dimension": {
        "difficulty_hint": "well_known",
        "display_name": "CSS Architecture and Styling",
        "id": 117,
        "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
        "slug": "css-architecture-and-styling",
        "source": "db"
      },
      "input_skill": "Styled Components",
      "llm_role": null,
      "roles_from_db": [
        {
          "display_name": "Frontend Developer",
          "id": 7,
          "rationale": null,
          "role_archetype": null,
          "slug": "frontend-engineer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 435,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "fullstack-developer",
          "source": "db"
        },
        {
          "display_name": "Fullstack Developer",
          "id": 15,
          "rationale": null,
          "role_archetype": null,
          "slug": "full-stack-engineer",
          "source": "db"
        },
        {
          "display_name": "React Frontend Developer",
          "id": 89,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "react-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Svelte Frontend Developer",
          "id": 92,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "svelte-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Vue Frontend Developer",
          "id": 91,
          "rationale": null,
          "role_archetype": "Engineering",
          "slug": "vue-frontend-developer",
          "source": "db"
        },
        {
          "display_name": "Web Developer",
          "id": 25,
          "rationale": null,
          "role_archetype": null,
          "slug": "web-developer",
          "source": "db"
        }
      ]
    }
  ],
  "input_final_skills": [
    "TypeScript",
    "React Native",
    "Swift",
    "Kotlin",
    "React Testing Library",
    "Jest",
    "Detox",
    "Git",
    "GitHub",
    "Gitflow",
    "Scrum",
    "Code Review",
    "Redux",
    "Redux Toolkit",
    "Redux-Logic",
    "Redux-Saga",
    "Formik",
    "React Hook Form",
    "JSON API",
    "Metro Bundler",
    "AR libraries",
    "Reanimated",
    "Styled Components",
    "Store normalization"
  ],
  "input_llm_skills": [
    "TypeScript",
    "React Native",
    "Swift",
    "Kotlin",
    "React Testing Library",
    "Jest",
    "Detox",
    "Git",
    "GitHub",
    "Gitflow",
    "Scrum",
    "Code Review",
    "Redux",
    "Redux Toolkit",
    "Redux-Logic",
    "Redux-Saga",
    "Formik",
    "React Hook Form",
    "JSON API",
    "Metro Bundler",
    "AR libraries",
    "Reanimated",
    "Styled Components",
    "Store normalization"
  ],
  "new_aliases_persisted": 0,
  "run_id": "e72afe83-94db-4905-a448-89e895aef164",
  "skills_detail": [
    {
      "aliases_in_db": [
        {
          "alias_text": "TypeScript",
          "alias_type": "CANONICAL",
          "id": 914,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 5",
          "alias_type": "VERSION",
          "id": 3157,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "TypeScript 5.x",
          "alias_type": "VERSION",
          "id": 3159,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ts",
          "alias_type": "VERSION",
          "id": 1647,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "ts5",
          "alias_type": "VERSION",
          "id": 1648,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "typescript 5",
          "alias_type": "VERSION",
          "id": 1649,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "typescript 5.x",
          "alias_type": "VERSION",
          "id": 1650,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "typescript5",
          "alias_type": "VERSION",
          "id": 2179,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "TypeScript",
        "id": 524,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "typescript",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform App Languages",
            "id": 167,
            "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
            "slug": "cross-platform-app-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "JavaScript and TypeScript",
            "id": 114,
            "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
            "slug": "javascript-and-typescript",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages",
            "id": 1,
            "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
            "slug": "programming-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Programming Languages for XR",
            "id": 97,
            "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
            "slug": "programming-languages-for-xr",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "AR/VR Engineer",
              "id": 8,
              "rationale": null,
              "role_archetype": null,
              "slug": "ar-vr-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Sitecore Development Languages",
            "id": 438,
            "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
            "slug": "sitecore-development-languages",
            "source": "db"
          },
          "input_skill": "TypeScript",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Sitecore Dev",
              "id": 233,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "sitecore-dev",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "TypeScript",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "React Native",
          "alias_type": "CANONICAL",
          "id": 1657,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 5,
        "display_name": "React Native",
        "id": 1040,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "FRAMEWORK",
        "slug": "react-native",
        "sub_category_id": 2146,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Cross-Platform Mobile UI Frameworks",
            "id": 319,
            "rationale": "Frameworks, rendering models, and component libraries used to build shared mobile screens, layouts, and interactive experiences across platforms. This includes React Native and related tooling such as React Native CLI and Expo, as well as cross-platform UI libraries and interaction patterns like React Native Paper, NativeBase, gesture handlers, and animated components; it also covers comparable hybrid mobile UI frameworks such as Flutter. Excludes browser-only frontend frameworks and native platform UI toolkits such as SwiftUI, UIKit, Jetpack Compose, and Android Views.",
            "slug": "cross-platform-mobile-ui-frameworks",
            "source": "db"
          },
          "input_skill": "React Native",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "UI Frameworks and Rendering",
            "id": 115,
            "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
            "slug": "ui-frameworks-and-rendering",
            "source": "db"
          },
          "input_skill": "React Native",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "React Native",
      "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": "Swift",
          "alias_type": "CANONICAL",
          "id": 756,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 2.0",
          "alias_type": "VERSION",
          "id": 757,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 2.x",
          "alias_type": "VERSION",
          "id": 758,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 3.0",
          "alias_type": "VERSION",
          "id": 759,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 3.x",
          "alias_type": "VERSION",
          "id": 760,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 4.0",
          "alias_type": "VERSION",
          "id": 761,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 4.x",
          "alias_type": "VERSION",
          "id": 762,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 5.0",
          "alias_type": "VERSION",
          "id": 763,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 5.x",
          "alias_type": "VERSION",
          "id": 764,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 6.0",
          "alias_type": "VERSION",
          "id": 765,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "Swift 6.x",
          "alias_type": "VERSION",
          "id": 766,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Swift",
        "id": 440,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "swift",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Languages",
            "id": 274,
            "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
            "slug": "native-mobile-languages",
            "source": "db"
          },
          "input_skill": "Swift",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Swift and Objective-C",
            "id": 81,
            "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
            "slug": "swift-and-objective-c",
            "source": "db"
          },
          "input_skill": "Swift",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "iOS Developer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Swift",
      "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": "Kotlin",
          "alias_type": "CANONICAL",
          "id": 24,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9",
          "alias_type": "VERSION",
          "id": 3102,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9.0",
          "alias_type": "VERSION",
          "id": 3104,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9.1",
          "alias_type": "VERSION",
          "id": 3105,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9.10",
          "alias_type": "VERSION",
          "id": 3107,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin 1.9.x",
          "alias_type": "VERSION",
          "id": 3106,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        },
        {
          "alias_text": "kotlin-1.9",
          "alias_type": "VERSION",
          "id": 3103,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 6,
        "display_name": "Kotlin",
        "id": 2,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LANGUAGE",
        "slug": "kotlin",
        "sub_category_id": 96,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Java Language and JVM",
            "id": 279,
            "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
            "slug": "java-language-and-jvm",
            "source": "db"
          },
          "input_skill": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Kotlin and Java",
            "id": 161,
            "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
            "slug": "kotlin-and-java",
            "source": "db"
          },
          "input_skill": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Native Mobile Languages",
            "id": 274,
            "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
            "slug": "native-mobile-languages",
            "source": "db"
          },
          "input_skill": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "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": "Kotlin",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Kotlin",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "React Testing Library",
          "alias_type": "CANONICAL",
          "id": 3924,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "React Testing Library",
        "id": 2548,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "react-testing-library",
        "sub_category_id": 491,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "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": "React Testing Library",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "React Testing Library",
      "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": "Jest",
          "alias_type": "CANONICAL",
          "id": 1156,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Jest",
        "id": 651,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "jest",
        "sub_category_id": 513,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "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": "Jest",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Mobile Testing Frameworks",
            "id": 168,
            "rationale": "Test tools and patterns used to validate shared mobile UI, integration, and device behavior. Hybrid developers rely on these to catch regressions in screen flows, state transitions, and platform-specific edge cases.",
            "slug": "mobile-testing-frameworks",
            "source": "db"
          },
          "input_skill": "Jest",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Testing and Integration Validation",
            "id": 217,
            "rationale": "Automated checks used to verify feature behavior across client, server, and data boundaries. Full stack engineers rely on this to catch regressions in end-to-end flows and integration points.",
            "slug": "testing-and-integration-validation",
            "source": "db"
          },
          "input_skill": "Jest",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Jest",
      "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": "Detox",
          "alias_type": "CANONICAL",
          "id": 1687,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Detox",
        "id": 1061,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "detox",
        "sub_category_id": 799,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Mobile Testing Frameworks",
            "id": 168,
            "rationale": "Test tools and patterns used to validate shared mobile UI, integration, and device behavior. Hybrid developers rely on these to catch regressions in screen flows, state transitions, and platform-specific edge cases.",
            "slug": "mobile-testing-frameworks",
            "source": "db"
          },
          "input_skill": "Detox",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Detox",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Git",
          "alias_type": "CANONICAL",
          "id": 1613,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Git",
        "id": 1002,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "git",
        "sub_category_id": 730,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Git",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Git",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "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": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Gitflow",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Practices",
          "skill_nature": "PRACTICE",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "gitflow",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Scrum",
          "alias_type": "CANONICAL",
          "id": 1851,
          "is_primary": true,
          "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": 3627,
        "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": []
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Software Concepts, Patterns \u0026 Practices",
            "id": 478,
            "rationale": "Champion foundational software design patterns, development methodologies, and engineering best practices.",
            "slug": "software-concepts-patterns-practices",
            "source": "db"
          },
          "input_skill": "Scrum",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Engineering Manager",
              "id": 121,
              "rationale": null,
              "role_archetype": null,
              "slug": "engineering-manager",
              "source": "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": [
        {
          "alias_text": "Code Review",
          "alias_type": "CANONICAL",
          "id": 864,
          "is_primary": false,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 58,
        "display_name": "Code Review",
        "id": 516,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PRACTICE",
        "slug": "code-review",
        "sub_category_id": 364,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Frontend Development",
            "id": 96,
            "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
            "slug": "d_init_01",
            "source": "db"
          },
          "input_skill": "Code Review",
          "llm_role": null,
          "roles_from_db": []
        }
      ],
      "input_skill": "Code Review",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Redux",
          "alias_type": "CANONICAL",
          "id": 1101,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "Redux",
        "id": 617,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "redux",
        "sub_category_id": 490,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "Screen Navigation and State",
            "id": 83,
            "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
            "slug": "screen-navigation-and-state",
            "source": "db"
          },
          "input_skill": "Redux",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Flutter Developer",
              "id": 74,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "flutter-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "Native Mobile Developer",
              "id": 75,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "native-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "React Native Developer",
              "id": 73,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-native-developer",
              "source": "db"
            },
            {
              "display_name": "iOS Developer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        },
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "State Management Patterns",
            "id": 116,
            "rationale": "Client-side state organization for forms, UI interactions, cached data, and cross-component coordination. This cluster is coherent because frontend work often hinges on predictable state transitions and data flow.",
            "slug": "state-management-patterns",
            "source": "db"
          },
          "input_skill": "Redux",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Flutter Developer",
              "id": 74,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "flutter-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Redux",
      "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": "Redux Toolkit",
          "alias_type": "CANONICAL",
          "id": 3859,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "Redux Toolkit",
        "id": 2519,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "redux-toolkit",
        "sub_category_id": 490,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "State Management Patterns",
            "id": 116,
            "rationale": "Client-side state organization for forms, UI interactions, cached data, and cross-component coordination. This cluster is coherent because frontend work often hinges on predictable state transitions and data flow.",
            "slug": "state-management-patterns",
            "source": "db"
          },
          "input_skill": "Redux Toolkit",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Angular Frontend Developer",
              "id": 90,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "angular-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Flutter Developer",
              "id": 74,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "flutter-developer",
              "source": "db"
            },
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Ionic Developer",
              "id": 434,
              "rationale": null,
              "role_archetype": null,
              "slug": "ionic-developer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Redux Toolkit",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Redux-Logic",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Web Frameworks",
          "skill_nature": "TOOL",
          "sub_category": "State Management",
          "typical_lifespan": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "redux-logic",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Redux-Saga",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Web Frameworks",
          "skill_nature": "TOOL",
          "sub_category": "State Management",
          "typical_lifespan": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "redux-saga",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Formik",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Web Frameworks",
          "skill_nature": "TOOL",
          "sub_category": "Forms",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "formik",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "React Hooks",
          "alias_type": "CANONICAL",
          "id": 3970,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 2,
        "display_name": "React Hooks",
        "id": 2594,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "CONCEPT",
        "slug": "react-hooks",
        "sub_category_id": 1902,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "React Component Architecture",
            "id": 302,
            "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
            "slug": "react-component-architecture",
            "source": "db"
          },
          "input_skill": "React Hook Form",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "React Hook Form",
      "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": "JSON:API",
          "alias_type": "CANONICAL",
          "id": 4606,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 10,
        "display_name": "JSON:API",
        "id": 3129,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "PROTOCOL",
        "slug": "json-api",
        "sub_category_id": 2347,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "External System Integrations",
            "id": 14,
            "rationale": "Connecting backend services to third-party APIs and internal enterprise systems. This includes client libraries, webhooks, retries, data mapping, and integration failure handling.",
            "slug": "external-system-integrations",
            "source": "db"
          },
          "input_skill": "JSON API",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": ".NET Backend Developer",
              "id": 83,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "dotnet-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Backend Developer",
              "id": 1,
              "rationale": null,
              "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
              "slug": "backend-engineer",
              "source": "db"
            },
            {
              "display_name": "Drupal Dev",
              "id": 228,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "drupal-dev",
              "source": "db"
            },
            {
              "display_name": "Java Backend Developer",
              "id": 79,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "java-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Kotlin Backend Developer",
              "id": 84,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "kotlin-server-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Node.js Backend Developer",
              "id": 82,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "node-backend-developer",
              "source": "db"
            },
            {
              "display_name": "PHP Backend Developer",
              "id": 86,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "php-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Python Backend Developer",
              "id": 80,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "python-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Ruby Backend Developer",
              "id": 85,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "ruby-backend-developer",
              "source": "db"
            },
            {
              "display_name": "Scala Backend Developer",
              "id": 87,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "scala-backend-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "JSON API",
      "matched_via": "embedding_display_name",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "Metro bundler",
          "alias_type": "CANONICAL",
          "id": 1694,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 13,
        "display_name": "Metro bundler",
        "id": 1068,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "TOOL",
        "slug": "metro-bundler",
        "sub_category_id": 797,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "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": "Metro Bundler",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Android Developer",
              "id": 4,
              "rationale": null,
              "role_archetype": null,
              "slug": "android-engineer",
              "source": "db"
            },
            {
              "display_name": "Flutter Developer",
              "id": 74,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "flutter-developer",
              "source": "db"
            },
            {
              "display_name": "Hybrid Mobile Developer",
              "id": 11,
              "rationale": null,
              "role_archetype": null,
              "slug": "hybrid-mobile-developer",
              "source": "db"
            },
            {
              "display_name": "iOS Developer",
              "id": 6,
              "rationale": null,
              "role_archetype": null,
              "slug": "ios-engineer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Metro Bundler",
      "matched_via": "alias",
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": null,
      "source_tag": "db",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "AR libraries",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Software Libraries",
          "skill_nature": "TOOL",
          "sub_category": "general",
          "typical_lifespan": "SHORT_LIVED",
          "version_strategy": "VERSIONED",
          "volatility": "FAST"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "ar-libraries",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [],
      "canonical": null,
      "dimensions": [],
      "input_skill": "Reanimated",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Web Frameworks",
          "skill_nature": "TOOL",
          "sub_category": "Animation",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "reanimated",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    },
    {
      "aliases_in_db": [
        {
          "alias_text": "styled-components",
          "alias_type": "CANONICAL",
          "id": 3865,
          "is_primary": true,
          "match_strategy": "CASE_INSENSITIVE"
        }
      ],
      "canonical": {
        "category_id": 7,
        "display_name": "styled-components",
        "id": 2525,
        "is_also_category": false,
        "is_extractable": true,
        "skill_nature": "LIBRARY",
        "slug": "styled-components",
        "sub_category_id": 1920,
        "typical_lifespan": "EVERGREEN",
        "volatility": "STABLE"
      },
      "dimensions": [
        {
          "dimension": {
            "difficulty_hint": "well_known",
            "display_name": "CSS Architecture and Styling",
            "id": 117,
            "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
            "slug": "css-architecture-and-styling",
            "source": "db"
          },
          "input_skill": "Styled Components",
          "llm_role": null,
          "roles_from_db": [
            {
              "display_name": "Frontend Developer",
              "id": 7,
              "rationale": null,
              "role_archetype": null,
              "slug": "frontend-engineer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 435,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "fullstack-developer",
              "source": "db"
            },
            {
              "display_name": "Fullstack Developer",
              "id": 15,
              "rationale": null,
              "role_archetype": null,
              "slug": "full-stack-engineer",
              "source": "db"
            },
            {
              "display_name": "React Frontend Developer",
              "id": 89,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "react-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Svelte Frontend Developer",
              "id": 92,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "svelte-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Vue Frontend Developer",
              "id": 91,
              "rationale": null,
              "role_archetype": "Engineering",
              "slug": "vue-frontend-developer",
              "source": "db"
            },
            {
              "display_name": "Web Developer",
              "id": 25,
              "rationale": null,
              "role_archetype": null,
              "slug": "web-developer",
              "source": "db"
            }
          ]
        }
      ],
      "input_skill": "Styled Components",
      "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": [],
      "input_skill": "Store normalization",
      "matched_via": null,
      "new_alias_persisted": false,
      "new_alias_text": null,
      "new_skill_meta": {
        "derived": {
          "category": "Concepts",
          "skill_nature": "CONCEPT",
          "sub_category": "general",
          "typical_lifespan": "MULTI_YEAR",
          "version_strategy": "UNVERSIONED",
          "volatility": "MEDIUM"
        },
        "enrichment": null,
        "keep_log": [],
        "locked_dimensions": [],
        "merge_log": [],
        "placed": null,
        "relationships": null,
        "skill_id": "store-normalization",
        "split_log": [],
        "typed": null,
        "warnings": []
      },
      "source_tag": "llm",
      "was_in_llm_skills": true
    }
  ],
  "unmatched_skills": [
    "Gitflow",
    "Redux-Logic",
    "Redux-Saga",
    "Formik",
    "AR libraries",
    "Reanimated",
    "Store normalization"
  ]
}
API 3 — final-role-output
{
  "chosen_role": {
    "display_name": "Hybrid Mobile Developer",
    "id": 11,
    "rationale": "Domain=Software Engineering \u2192 sub-role react-native-developer; The JD is centered on React Native mobile app development with TypeScript and related mobile testing, state management, and publishing workflows, which best matches Hybrid Mobile Developer.",
    "role_archetype": null,
    "slug": "hybrid-mobile-developer",
    "source": "db"
  },
  "chosen_role_resolution": "in_db",
  "final_input_skills": [
    {
      "skill": "TypeScript",
      "tag": "in_db"
    },
    {
      "skill": "React Native",
      "tag": "in_db"
    },
    {
      "skill": "Swift",
      "tag": "in_db"
    },
    {
      "skill": "Kotlin",
      "tag": "in_db"
    },
    {
      "skill": "React Testing Library",
      "tag": "in_db"
    },
    {
      "skill": "Jest",
      "tag": "in_db"
    },
    {
      "skill": "Detox",
      "tag": "in_db"
    },
    {
      "skill": "Git",
      "tag": "in_db"
    },
    {
      "skill": "GitHub",
      "tag": "in_db"
    },
    {
      "skill": "Gitflow",
      "tag": "new"
    },
    {
      "skill": "Scrum",
      "tag": "in_db"
    },
    {
      "skill": "Code Review",
      "tag": "in_db"
    },
    {
      "skill": "Redux",
      "tag": "in_db"
    },
    {
      "skill": "Redux Toolkit",
      "tag": "in_db"
    },
    {
      "skill": "Redux-Logic",
      "tag": "new"
    },
    {
      "skill": "Redux-Saga",
      "tag": "new"
    },
    {
      "skill": "Formik",
      "tag": "new"
    },
    {
      "skill": "React Hook Form",
      "tag": "in_db"
    },
    {
      "skill": "JSON API",
      "tag": "in_db"
    },
    {
      "skill": "Metro Bundler",
      "tag": "in_db"
    },
    {
      "skill": "AR libraries",
      "tag": "new"
    },
    {
      "skill": "Reanimated",
      "tag": "new"
    },
    {
      "skill": "Styled Components",
      "tag": "in_db"
    },
    {
      "skill": "Store normalization",
      "tag": "new"
    }
  ],
  "llm_cost_api1_usd": null,
  "llm_cost_api2_usd": null,
  "llm_cost_api3_usd": null,
  "llm_cost_total_usd": null,
  "persistence": {
    "items": [
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform App Languages",
          "id": 167,
          "rationale": "Languages used to implement shared mobile features across iOS and Android from a common codebase. This is the primary coding surface for hybrid app logic, UI behavior, and platform-specific branching.",
          "slug": "cross-platform-app-languages",
          "source": "db"
        },
        "dimension_id": 167,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "JavaScript and TypeScript",
          "id": 114,
          "rationale": "Primary implementation languages for browser client code, UI logic, and shared frontend utilities. These languages are the main coding surface for building interactive web experiences in this role.",
          "slug": "javascript-and-typescript",
          "source": "db"
        },
        "dimension_id": 114,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages for XR",
          "id": 97,
          "rationale": "Primary implementation languages used to build immersive client features, interaction logic, and device-specific runtime behavior. This is the core coding surface for AR/VR experiences.",
          "slug": "programming-languages-for-xr",
          "source": "db"
        },
        "dimension_id": 97,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "AR/VR Engineer",
            "id": 8,
            "rationale": null,
            "role_archetype": null,
            "slug": "ar-vr-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Sitecore Development Languages",
          "id": 438,
          "rationale": "Core implementation languages and markup used to build Sitecore customizations, rendering logic, and site behavior. This is the primary authoring surface for Sitecore-specific code and templates.",
          "slug": "sitecore-development-languages",
          "source": "db"
        },
        "dimension_id": 438,
        "input_skill": "TypeScript",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Sitecore Dev",
            "id": 233,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "sitecore-dev",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 524,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Cross-Platform Mobile UI Frameworks",
          "id": 319,
          "rationale": "Frameworks, rendering models, and component libraries used to build shared mobile screens, layouts, and interactive experiences across platforms. This includes React Native and related tooling such as React Native CLI and Expo, as well as cross-platform UI libraries and interaction patterns like React Native Paper, NativeBase, gesture handlers, and animated components; it also covers comparable hybrid mobile UI frameworks such as Flutter. Excludes browser-only frontend frameworks and native platform UI toolkits such as SwiftUI, UIKit, Jetpack Compose, and Android Views.",
          "slug": "cross-platform-mobile-ui-frameworks",
          "source": "db"
        },
        "dimension_id": 319,
        "input_skill": "React Native",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1040,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "UI Frameworks and Rendering",
          "id": 115,
          "rationale": "Component frameworks and rendering models used to build browser screens, reusable UI, and interactive client flows. This is a core cluster because frontend engineers spend much of their time composing and updating view hierarchies.",
          "slug": "ui-frameworks-and-rendering",
          "source": "db"
        },
        "dimension_id": 115,
        "input_skill": "React Native",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1040,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Native Mobile Languages",
          "id": 274,
          "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
          "slug": "native-mobile-languages",
          "source": "db"
        },
        "dimension_id": 274,
        "input_skill": "Swift",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 440,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Swift and Objective-C",
          "id": 81,
          "rationale": "Primary implementation languages for native iOS app features, platform APIs, and client-side business logic. This is the core coding surface for building and maintaining iPhone and iPad experiences.",
          "slug": "swift-and-objective-c",
          "source": "db"
        },
        "dimension_id": 81,
        "input_skill": "Swift",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "iOS Developer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 440,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Java Language and JVM",
          "id": 279,
          "rationale": "Core Java implementation skills used to build backend service logic, utilities, and internal abstractions. This is the primary coding surface for the role and includes language features plus JVM behavior that affect correctness and maintainability.",
          "slug": "java-language-and-jvm",
          "source": "db"
        },
        "dimension_id": 279,
        "input_skill": "Kotlin",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Kotlin and Java",
          "id": 161,
          "rationale": "Primary implementation languages for Android app features, platform integration, and client-side business logic. Android engineers use these languages to build screens, state flows, service adapters, and device-aware behavior.",
          "slug": "kotlin-and-java",
          "source": "db"
        },
        "dimension_id": 161,
        "input_skill": "Kotlin",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Native Mobile Languages",
          "id": 274,
          "rationale": "Primary implementation languages used to build platform-specific app features, UI logic, and device integrations. This is the core coding surface for native mobile work on one platform.",
          "slug": "native-mobile-languages",
          "source": "db"
        },
        "dimension_id": 274,
        "input_skill": "Kotlin",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Programming Languages",
          "id": 1,
          "rationale": "Primary implementation languages used to build client and server feature code. Full stack engineers need enough fluency to move across layers and implement product behavior end to end.",
          "slug": "programming-languages",
          "source": "db"
        },
        "dimension_id": 1,
        "input_skill": "Kotlin",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "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"
        },
        "dimension_id": 122,
        "input_skill": "React Testing Library",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2548,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "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"
        },
        "dimension_id": 122,
        "input_skill": "Jest",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 651,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Mobile Testing Frameworks",
          "id": 168,
          "rationale": "Test tools and patterns used to validate shared mobile UI, integration, and device behavior. Hybrid developers rely on these to catch regressions in screen flows, state transitions, and platform-specific edge cases.",
          "slug": "mobile-testing-frameworks",
          "source": "db"
        },
        "dimension_id": 168,
        "input_skill": "Jest",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 651,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Testing and Integration Validation",
          "id": 217,
          "rationale": "Automated checks used to verify feature behavior across client, server, and data boundaries. Full stack engineers rely on this to catch regressions in end-to-end flows and integration points.",
          "slug": "testing-and-integration-validation",
          "source": "db"
        },
        "dimension_id": 217,
        "input_skill": "Jest",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 651,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Mobile Testing Frameworks",
          "id": 168,
          "rationale": "Test tools and patterns used to validate shared mobile UI, integration, and device behavior. Hybrid developers rely on these to catch regressions in screen flows, state transitions, and platform-specific edge cases.",
          "slug": "mobile-testing-frameworks",
          "source": "db"
        },
        "dimension_id": 168,
        "input_skill": "Detox",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1061,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Git",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1002,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD Pipeline Platforms",
          "id": 150,
          "rationale": "Systems used to define, run, and maintain automated build and deployment workflows. This cluster is coherent because the role owns delivery automation end to end, including pipeline reliability and promotion logic.",
          "slug": "ci-cd-pipeline-platforms",
          "source": "db"
        },
        "dimension_id": 150,
        "input_skill": "GitHub",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "DevOps Engineer",
            "id": 10,
            "rationale": null,
            "role_archetype": null,
            "slug": "devops-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 280,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CI/CD for Machine Learning",
          "id": 56,
          "rationale": "Tools and platforms for automating ML model integration, testing, and deployment pipelines.",
          "slug": "ci-cd-for-machine-learning",
          "source": "db"
        },
        "dimension_id": 56,
        "input_skill": "GitHub",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "ML Engineer",
            "id": 3,
            "rationale": null,
            "role_archetype": null,
            "slug": "ml-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 280,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Scrum",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 1215,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Software Concepts, Patterns \u0026 Practices",
          "id": 478,
          "rationale": "Champion foundational software design patterns, development methodologies, and engineering best practices.",
          "slug": "software-concepts-patterns-practices",
          "source": "db"
        },
        "dimension_id": 478,
        "input_skill": "Scrum",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Engineering Manager",
            "id": 121,
            "rationale": null,
            "role_archetype": null,
            "slug": "engineering-manager",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1215,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Frontend Development",
          "id": 96,
          "rationale": "Building interactive web user interfaces with React.js, including component composition, state management, hooks, and rendering patterns. React.js belongs here because it is a core library for client-side UI development in modern web applications.",
          "slug": "d_init_01",
          "source": "db"
        },
        "dimension_id": 96,
        "input_skill": "Code Review",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [],
        "skill_dimension_saved": true,
        "skill_id": 516,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "Screen Navigation and State",
          "id": 83,
          "rationale": "Patterns for moving users through app flows and keeping client state consistent across screens, refreshes, and app transitions. This is central to feature work because iOS engineers own the in-app request flow and UI logic.",
          "slug": "screen-navigation-and-state",
          "source": "db"
        },
        "dimension_id": 83,
        "input_skill": "Redux",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Flutter Developer",
            "id": 74,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "flutter-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "Native Mobile Developer",
            "id": 75,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "native-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "React Native Developer",
            "id": 73,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-native-developer",
            "source": "db"
          },
          {
            "display_name": "iOS Developer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 617,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "State Management Patterns",
          "id": 116,
          "rationale": "Client-side state organization for forms, UI interactions, cached data, and cross-component coordination. This cluster is coherent because frontend work often hinges on predictable state transitions and data flow.",
          "slug": "state-management-patterns",
          "source": "db"
        },
        "dimension_id": 116,
        "input_skill": "Redux",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Flutter Developer",
            "id": 74,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "flutter-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 617,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "State Management Patterns",
          "id": 116,
          "rationale": "Client-side state organization for forms, UI interactions, cached data, and cross-component coordination. This cluster is coherent because frontend work often hinges on predictable state transitions and data flow.",
          "slug": "state-management-patterns",
          "source": "db"
        },
        "dimension_id": 116,
        "input_skill": "Redux Toolkit",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension skipped (dimension not under chosen role)",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Angular Frontend Developer",
            "id": 90,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "angular-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Flutter Developer",
            "id": 74,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "flutter-developer",
            "source": "db"
          },
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Ionic Developer",
            "id": 434,
            "rationale": null,
            "role_archetype": null,
            "slug": "ionic-developer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 2519,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "React Component Architecture",
          "id": 302,
          "rationale": "Building reusable React components, composing props and children, and managing rendering behavior across feature screens. This is the primary framework cluster for a React frontend developer.",
          "slug": "react-component-architecture",
          "source": "db"
        },
        "dimension_id": 302,
        "input_skill": "React Hook Form",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Skipped \u2014 no persistable v3 meta for new skill",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": false,
        "skill_id": null,
        "skill_tag": "new",
        "skipped_reason": "skill_not_in_db_v3_proposed"
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "External System Integrations",
          "id": 14,
          "rationale": "Connecting backend services to third-party APIs and internal enterprise systems. This includes client libraries, webhooks, retries, data mapping, and integration failure handling.",
          "slug": "external-system-integrations",
          "source": "db"
        },
        "dimension_id": 14,
        "input_skill": "JSON API",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Skipped \u2014 no persistable v3 meta for new skill",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": ".NET Backend Developer",
            "id": 83,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "dotnet-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Backend Developer",
            "id": 1,
            "rationale": null,
            "role_archetype": "A Backend Engineer designs, builds, and maintains the server-side logic and data handling that power applications and services. They focus on implementing reliable business functionality, integrating with other systems, and ensuring the backend is scalable, maintainable, and observable.",
            "slug": "backend-engineer",
            "source": "db"
          },
          {
            "display_name": "Drupal Dev",
            "id": 228,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "drupal-dev",
            "source": "db"
          },
          {
            "display_name": "Java Backend Developer",
            "id": 79,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "java-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Kotlin Backend Developer",
            "id": 84,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "kotlin-server-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Node.js Backend Developer",
            "id": 82,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "node-backend-developer",
            "source": "db"
          },
          {
            "display_name": "PHP Backend Developer",
            "id": 86,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "php-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Python Backend Developer",
            "id": 80,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "python-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Ruby Backend Developer",
            "id": 85,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "ruby-backend-developer",
            "source": "db"
          },
          {
            "display_name": "Scala Backend Developer",
            "id": 87,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "scala-backend-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": false,
        "skill_id": null,
        "skill_tag": "new",
        "skipped_reason": "skill_not_in_db_v3_proposed"
      },
      {
        "chosen_role_id": 11,
        "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"
        },
        "dimension_id": 89,
        "input_skill": "Metro Bundler",
        "llm_role": null,
        "matched_chosen_role": true,
        "outcome_line": "Existing dimension (library) \u00b7 Role\u2194dimension saved",
        "role_dimension_saved": true,
        "roles_from_db": [
          {
            "display_name": "Android Developer",
            "id": 4,
            "rationale": null,
            "role_archetype": null,
            "slug": "android-engineer",
            "source": "db"
          },
          {
            "display_name": "Flutter Developer",
            "id": 74,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "flutter-developer",
            "source": "db"
          },
          {
            "display_name": "Hybrid Mobile Developer",
            "id": 11,
            "rationale": null,
            "role_archetype": null,
            "slug": "hybrid-mobile-developer",
            "source": "db"
          },
          {
            "display_name": "iOS Developer",
            "id": 6,
            "rationale": null,
            "role_archetype": null,
            "slug": "ios-engineer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": true,
        "skill_id": 1068,
        "skill_tag": "in_db",
        "skipped_reason": null
      },
      {
        "chosen_role_id": 11,
        "dimension": {
          "difficulty_hint": "well_known",
          "display_name": "CSS Architecture and Styling",
          "id": 117,
          "rationale": "Styling systems and layout techniques used to create responsive, maintainable visual presentation in the browser. Frontend engineers need this to translate design intent into consistent interfaces.",
          "slug": "css-architecture-and-styling",
          "source": "db"
        },
        "dimension_id": 117,
        "input_skill": "Styled Components",
        "llm_role": null,
        "matched_chosen_role": false,
        "outcome_line": "Skipped \u2014 no persistable v3 meta for new skill",
        "role_dimension_saved": false,
        "roles_from_db": [
          {
            "display_name": "Frontend Developer",
            "id": 7,
            "rationale": null,
            "role_archetype": null,
            "slug": "frontend-engineer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 435,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "fullstack-developer",
            "source": "db"
          },
          {
            "display_name": "Fullstack Developer",
            "id": 15,
            "rationale": null,
            "role_archetype": null,
            "slug": "full-stack-engineer",
            "source": "db"
          },
          {
            "display_name": "React Frontend Developer",
            "id": 89,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "react-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Svelte Frontend Developer",
            "id": 92,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "svelte-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Vue Frontend Developer",
            "id": 91,
            "rationale": null,
            "role_archetype": "Engineering",
            "slug": "vue-frontend-developer",
            "source": "db"
          },
          {
            "display_name": "Web Developer",
            "id": 25,
            "rationale": null,
            "role_archetype": null,
            "slug": "web-developer",
            "source": "db"
          }
        ],
        "skill_dimension_saved": false,
        "skill_id": null,
        "skill_tag": "new",
        "skipped_reason": "skill_not_in_db_v3_proposed"
      }
    ],
    "new_skills_created": 0,
    "role_dimension_saved": 0,
    "skill_dimension_saved": 0,
    "skipped": 3
  },
  "planner_output": null,
  "run_id": "e72afe83-94db-4905-a448-89e895aef164"
}