diff --git a/.github/actions/test-summary/action.yml b/.github/actions/test-summary/action.yml
new file mode 100644
index 000000000000..344bb472fb37
--- /dev/null
+++ b/.github/actions/test-summary/action.yml
@@ -0,0 +1,89 @@
+name: 'Test Summary'
+description: 'Parse JUnit XML reports and write a failure summary to GITHUB_STEP_SUMMARY'
+
+inputs:
+  report-type:
+    description: 'Type of test report directory (test or integrationTest)'
+    required: true
+    default: 'test'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Generate test summary
+      if: always()
+      shell: bash
+      run: |
+        shopt -s globstar nullglob
+
+        report_type="${{ inputs.report-type }}"
+        files=(**/build/test-results/${report_type}/TEST-*.xml)
+
+        if [ ${#files[@]} -eq 0 ]; then
+          echo "No test result files found."
+          exit 0
+        fi
+
+        total=0
+        failed=0
+        errored=0
+        skipped=0
+        failure_details=""
+
+        for f in "${files[@]}"; do
+          # Extract testsuite attributes
+          suite_line=$(head -5 "$f" | grep '<testsuite ')
+          if [ -z "$suite_line" ]; then continue; fi
+
+          t=$(echo "$suite_line" | grep -oP 'tests="\K[0-9]+' || echo 0)
+          fl=$(echo "$suite_line" | grep -oP 'failures="\K[0-9]+' || echo 0)
+          e=$(echo "$suite_line" | grep -oP 'errors="\K[0-9]+' || echo 0)
+          s=$(echo "$suite_line" | grep -oP 'skipped="\K[0-9]+' || echo 0)
+
+          total=$((total + t))
+          failed=$((failed + fl))
+          errored=$((errored + e))
+          skipped=$((skipped + s))
+
+          # Collect failure details
+          if [ "$fl" -gt 0 ] || [ "$e" -gt 0 ]; then
+            # Use python for reliable XML parsing of failure messages
+            details=$(python3 -c "
+        import xml.etree.ElementTree as ET, sys
+        try:
+            tree = ET.parse('$f')
+            for tc in tree.findall('.//testcase'):
+                fail = tc.find('failure')
+                err = tc.find('error')
+                elem = fail if fail is not None else err
+                if elem is not None:
+                    cls = tc.get('classname', '')
+                    name = tc.get('name', '')
+                    msg = elem.get('message', '')[:200].replace('|', '/').replace('\n', ' ')
+                    print(f'| \`{cls}\` | \`{name}\` | {msg} |')
+        except Exception:
+            pass
+        " 2>/dev/null || true)
+            if [ -n "$details" ]; then
+              failure_details="${failure_details}${details}"$'\n'
+            fi
+          fi
+        done
+
+        passed=$((total - failed - errored - skipped))
+
+        if [ "$failed" -eq 0 ] && [ "$errored" -eq 0 ]; then
+          summary="Tests passed: $passed, skipped: $skipped"
+          echo "$summary"
+          echo "### :white_check_mark: $summary" >> "$GITHUB_STEP_SUMMARY"
+        else
+          summary="Tests: $passed passed, $((failed + errored)) failed, $skipped skipped (total: $total)"
+          echo "::error::$summary"
+          echo ""
+          echo "$failure_details"
+          echo "### :x: $summary" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Class | Test | Message |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|-------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
+          echo "$failure_details" >> "$GITHUB_STEP_SUMMARY"
+        fi
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 000000000000..8f1a967085aa
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,45 @@
+name: Build
+
+on:
+  push:
+    branches: [ ignite-di-claude ]
+  pull_request:
+    branches: [ ignite-di-claude ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: false
+
+      - name: Build (skip tests and checks)
+        run: ./gradlew clean build -x assembleDist -x distTar -x distZip -x check
+
+  checks:
+    name: Checks
+    needs: build
+    uses: ./.github/workflows/checks.yml
+
+  unit-tests:
+    name: Unit Tests
+    needs: checks
+    uses: ./.github/workflows/unit-tests.yml
+
+  integration-tests:
+    name: Integration Tests
+    needs: unit-tests
+    uses: ./.github/workflows/integration-tests.yml
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
new file mode 100644
index 000000000000..49ec8d5a864c
--- /dev/null
+++ b/.github/workflows/checks.yml
@@ -0,0 +1,167 @@
+name: Checks
+
+on:
+  workflow_call:
+
+jobs:
+  checkstyle:
+    name: Checkstyle
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run Checkstyle
+        run: ./gradlew --continue checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
+
+      - name: Summarize Checkstyle violations
+        if: always()
+        shell: bash
+        run: |
+          shopt -s globstar nullglob
+          files=(**/build/reports/checkstyle/*.xml)
+          if [ ${#files[@]} -eq 0 ]; then exit 0; fi
+          violations=$(grep -h '<error ' "${files[@]}" 2>/dev/null || true)
+          if [ -z "$violations" ]; then
+            echo "Checkstyle: No violations"
+            echo "### :white_check_mark: Checkstyle: No violations" >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+          echo "::error::Checkstyle violations found"
+          echo "### :x: Checkstyle Violations" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| File | Line | Message |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
+          for f in "${files[@]}"; do
+            grep '<error ' "$f" 2>/dev/null | sed -E 's/.*line="([0-9]+)".*message="([^"]+)".*/\1|\2/' | while IFS='|' read -r line msg; do
+              src=$(grep -oP 'name="\K[^"]+' "$f" | head -1)
+              short=$(echo "$src" | sed 's|.*/src/||')
+              echo "::error file=$short,line=$line::$msg"
+              echo "| \`$short\` | $line | $msg |" >> "$GITHUB_STEP_SUMMARY"
+            done
+          done
+
+  pmd:
+    name: PMD
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run PMD
+        run: ./gradlew --continue pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
+
+      - name: Summarize PMD violations
+        if: always()
+        shell: bash
+        run: |
+          shopt -s globstar nullglob
+          files=(**/build/reports/pmd/*.xml)
+          if [ ${#files[@]} -eq 0 ]; then exit 0; fi
+          violations=$(grep -h '<violation ' "${files[@]}" 2>/dev/null || true)
+          if [ -z "$violations" ]; then
+            echo "PMD: No violations"
+            echo "### :white_check_mark: PMD: No violations" >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+          echo "::error::PMD violations found"
+          echo "### :x: PMD Violations" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| File | Line | Rule | Message |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|------|------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
+          for f in "${files[@]}"; do
+            current_file=""
+            while IFS= read -r line; do
+              if echo "$line" | grep -qP '<file name="'; then
+                current_file=$(echo "$line" | grep -oP 'name="\K[^"]+' | sed 's|.*/src/||')
+              fi
+              if echo "$line" | grep -qP '<violation '; then
+                lineno=$(echo "$line" | grep -oP 'beginline="\K[0-9]+')
+                rule=$(echo "$line" | grep -oP 'rule="\K[^"]+')
+                msg=$(echo "$line" | sed -E 's/.*>([^<]+)<\/violation>.*/\1/' | xargs)
+                echo "::error file=$current_file,line=$lineno::[$rule] $msg"
+                echo "| \`$current_file\` | $lineno | $rule | $msg |" >> "$GITHUB_STEP_SUMMARY"
+              fi
+            done < "$f"
+          done
+
+  spotbugs:
+    name: SpotBugs
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run SpotBugs
+        run: ./gradlew --continue spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures
+
+      - name: Summarize SpotBugs violations
+        if: always()
+        shell: bash
+        run: |
+          shopt -s globstar nullglob
+          files=(**/build/reports/spotbugs/*.xml)
+          if [ ${#files[@]} -eq 0 ]; then exit 0; fi
+          bugs=$(grep -h '<BugInstance ' "${files[@]}" 2>/dev/null || true)
+          if [ -z "$bugs" ]; then
+            echo "SpotBugs: No bugs found"
+            echo "### :white_check_mark: SpotBugs: No bugs found" >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+          echo "::error::SpotBugs issues found"
+          echo "### :x: SpotBugs Issues" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Type | Category | Class | Line | Message |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|------|----------|-------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
+          for f in "${files[@]}"; do
+            python3 -c "
+          import xml.etree.ElementTree as ET, os
+          tree = ET.parse('$f')
+          summary = open(os.environ['GITHUB_STEP_SUMMARY'], 'a')
+          for bug in tree.findall('.//BugInstance'):
+              typ = bug.get('type', '')
+              cat = bug.get('category', '')
+              msg_el = bug.find('ShortMessage')
+              msg = msg_el.text if msg_el is not None else ''
+              cls_el = bug.find('Class')
+              cls = cls_el.get('classname', '') if cls_el is not None else ''
+              src_el = bug.find('.//SourceLine[@start]')
+              line = src_el.get('start', '') if src_el is not None else ''
+              print(f'::error::[{typ}] {cls}:{line} - {msg}')
+              summary.write(f'| \`{typ}\` | {cat} | \`{cls}\` | {line} | {msg} |\n')
+          summary.close()
+          " 2>/dev/null || true
+          done
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
new file mode 100644
index 000000000000..52c2fb19f33b
--- /dev/null
+++ b/.github/workflows/integration-tests.yml
@@ -0,0 +1,417 @@
+name: Integration Tests
+
+on:
+  workflow_call:
+
+jobs:
+  core:
+    name: Core
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-eventlog:integrationTest
+          :ignite-failure-handler:integrationTest
+          :ignite-workers:integrationTest
+          :ignite-configuration-annotation-processor:integrationTest
+          :ignite-file-transfer:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-core
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  network:
+    name: Network
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-network:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-network
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  storage:
+    name: Storage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-page-memory:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-storage
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  sql:
+    name: SQL
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-sql-engine:integrationTest
+          :ignite-catalog:integrationTest
+          :ignite-catalog-compaction:integrationTest
+          :ignite-catalog-dsl:integrationTest
+          :ignite-jdbc:integrationTest
+          :ignite-schema-sync:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-sql
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  raft-replication:
+    name: Raft & Replication
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-raft:integrationTest
+          :ignite-replicator:integrationTest
+          :ignite-partition-replicator:integrationTest
+          :ignite-metastorage:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-raft-replication
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  table-index:
+    name: Table & Index
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-table:integrationTest
+          :ignite-index:integrationTest
+          :ignite-distribution-zones:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-table-index
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  compute-deployment:
+    name: Compute & Deployment
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-compute:integrationTest
+          :ignite-code-deployment:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-compute-deployment
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  client:
+    name: Client
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-client-handler:integrationTest
+          :ignite-rest:integrationTest
+          :ignite-cli:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-client
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  runner:
+    name: Runner
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-runner:integrationTest
+          :ignite-cluster-management:integrationTest
+          :ignite-placement-driver:integrationTest
+          :ignite-security:integrationTest
+          :ignite-transactions:integrationTest
+          :ignite-system-disaster-recovery:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-runner
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  misc:
+    name: Misc
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue integrationTest
+          -x :ignite-eventlog:integrationTest
+          -x :ignite-failure-handler:integrationTest
+          -x :ignite-workers:integrationTest
+          -x :ignite-configuration-annotation-processor:integrationTest
+          -x :ignite-file-transfer:integrationTest
+          -x :ignite-network:integrationTest
+          -x :ignite-page-memory:integrationTest
+          -x :ignite-sql-engine:integrationTest
+          -x :ignite-catalog:integrationTest
+          -x :ignite-catalog-compaction:integrationTest
+          -x :ignite-catalog-dsl:integrationTest
+          -x :ignite-jdbc:integrationTest
+          -x :ignite-schema-sync:integrationTest
+          -x :ignite-raft:integrationTest
+          -x :ignite-replicator:integrationTest
+          -x :ignite-partition-replicator:integrationTest
+          -x :ignite-metastorage:integrationTest
+          -x :ignite-table:integrationTest
+          -x :ignite-index:integrationTest
+          -x :ignite-distribution-zones:integrationTest
+          -x :ignite-compute:integrationTest
+          -x :ignite-code-deployment:integrationTest
+          -x :ignite-client-handler:integrationTest
+          -x :ignite-rest:integrationTest
+          -x :ignite-cli:integrationTest
+          -x :ignite-runner:integrationTest
+          -x :ignite-cluster-management:integrationTest
+          -x :ignite-placement-driver:integrationTest
+          -x :ignite-security:integrationTest
+          -x :ignite-transactions:integrationTest
+          -x :ignite-system-disaster-recovery:integrationTest
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-misc
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
new file mode 100644
index 000000000000..5ead382e6b1c
--- /dev/null
+++ b/.github/workflows/unit-tests.yml
@@ -0,0 +1,516 @@
+name: Unit Tests
+
+on:
+  workflow_call:
+
+jobs:
+  core:
+    name: Core
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-api:test
+          :ignite-arch-test:test
+          :ignite-binary-tuple:test
+          :ignite-bytecode:test
+          :ignite-core:test
+          :ignite-di:test
+          :ignite-failure-handler:test
+          :ignite-file-io:test
+          :ignite-marshaller-common:test
+          :ignite-workers:test
+          :ignite-vault:test
+          :ignite-eventlog:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-core
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  configuration:
+    name: Configuration
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-configuration:test
+          :ignite-configuration-annotation-processor:test
+          :ignite-configuration-presentation:test
+          :ignite-configuration-storage:test
+          :ignite-configuration-system:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-configuration
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  network:
+    name: Network
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-network:test
+          :ignite-network-annotation-processor:test
+          :ignite-network-api:test
+          :ignite-file-transfer:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-network
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  storage:
+    name: Storage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-storage-api:test
+          :ignite-storage-page-memory:test
+          :ignite-storage-rocksdb:test
+          :ignite-page-memory:test
+          :ignite-rocksdb-common:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-storage
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  sql:
+    name: SQL
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-sql-engine:test
+          :ignite-catalog:test
+          :ignite-catalog-compaction:test
+          :ignite-catalog-dsl:test
+          :ignite-jdbc:test
+          :ignite-schema:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-sql
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  raft-replication:
+    name: Raft & Replication
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-raft:test
+          :ignite-raft-api:test
+          :ignite-replicator:test
+          :ignite-partition-replicator:test
+          :ignite-metastorage:test
+          :ignite-metastorage-api:test
+          :ignite-metastorage-cache:test
+          :ignite-low-watermark:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-raft-replication
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  table-index:
+    name: Table & Index
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-table:test
+          :ignite-index:test
+          :ignite-distribution-zones:test
+          :ignite-partition-distribution:test
+          :ignite-system-view:test
+          :ignite-system-view-api:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-table-index
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  compute-deployment:
+    name: Compute & Deployment
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-compute:test
+          :ignite-code-deployment:test
+          :ignite-code-deployment-classloader:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-compute-deployment
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  client:
+    name: Client
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-client:test
+          :ignite-client-common:test
+          :ignite-client-handler:test
+          :ignite-rest:test
+          :ignite-rest-api:test
+          :ignite-cli:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-client
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  runner:
+    name: Runner
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-runner:test
+          :ignite-cluster-management:test
+          :ignite-placement-driver:test
+          :ignite-placement-driver-api:test
+          :ignite-security:test
+          :ignite-transactions:test
+          :ignite-system-disaster-recovery:test
+          :ignite-system-disaster-recovery-api:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-runner
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  misc:
+    name: Misc
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue test
+          -x :ignite-api:test
+          -x :ignite-arch-test:test
+          -x :ignite-binary-tuple:test
+          -x :ignite-bytecode:test
+          -x :ignite-core:test
+          -x :ignite-di:test
+          -x :ignite-failure-handler:test
+          -x :ignite-file-io:test
+          -x :ignite-marshaller-common:test
+          -x :ignite-workers:test
+          -x :ignite-vault:test
+          -x :ignite-eventlog:test
+          -x :ignite-configuration:test
+          -x :ignite-configuration-annotation-processor:test
+          -x :ignite-configuration-presentation:test
+          -x :ignite-configuration-storage:test
+          -x :ignite-configuration-system:test
+          -x :ignite-network:test
+          -x :ignite-network-annotation-processor:test
+          -x :ignite-network-api:test
+          -x :ignite-file-transfer:test
+          -x :ignite-storage-api:test
+          -x :ignite-storage-page-memory:test
+          -x :ignite-storage-rocksdb:test
+          -x :ignite-page-memory:test
+          -x :ignite-rocksdb-common:test
+          -x :ignite-sql-engine:test
+          -x :ignite-catalog:test
+          -x :ignite-catalog-compaction:test
+          -x :ignite-catalog-dsl:test
+          -x :ignite-jdbc:test
+          -x :ignite-schema:test
+          -x :ignite-raft:test
+          -x :ignite-raft-api:test
+          -x :ignite-replicator:test
+          -x :ignite-partition-replicator:test
+          -x :ignite-metastorage:test
+          -x :ignite-metastorage-api:test
+          -x :ignite-metastorage-cache:test
+          -x :ignite-low-watermark:test
+          -x :ignite-table:test
+          -x :ignite-index:test
+          -x :ignite-distribution-zones:test
+          -x :ignite-partition-distribution:test
+          -x :ignite-system-view:test
+          -x :ignite-system-view-api:test
+          -x :ignite-compute:test
+          -x :ignite-code-deployment:test
+          -x :ignite-code-deployment-classloader:test
+          -x :ignite-client:test
+          -x :ignite-client-common:test
+          -x :ignite-client-handler:test
+          -x :ignite-rest:test
+          -x :ignite-rest-api:test
+          -x :ignite-cli:test
+          -x :ignite-runner:test
+          -x :ignite-cluster-management:test
+          -x :ignite-placement-driver:test
+          -x :ignite-placement-driver-api:test
+          -x :ignite-security:test
+          -x :ignite-transactions:test
+          -x :ignite-system-disaster-recovery:test
+          -x :ignite-system-disaster-recovery-api:test
+
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-misc
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index bf6498d4532f..a20afe5b881d 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -42,7 +42,7 @@
         </value>
       </option>
     </AndroidXmlCodeStyleSettings>
-    <JSCodeStyleSettings>
+    <JSCodeStyleSettings version="0">
       <option name="INDENT_CHAINED_CALLS" value="false" />
     </JSCodeStyleSettings>
     <JavaCodeStyleSettings>
@@ -112,7 +112,7 @@
     <Python>
       <option name="USE_CONTINUATION_INDENT_FOR_ARGUMENTS" value="true" />
     </Python>
-    <TypeScriptCodeStyleSettings>
+    <TypeScriptCodeStyleSettings version="0">
       <option name="INDENT_CHAINED_CALLS" value="false" />
     </TypeScriptCodeStyleSettings>
     <XML>
@@ -200,7 +200,6 @@
       <option name="DOWHILE_BRACE_FORCE" value="3" />
       <option name="WHILE_BRACE_FORCE" value="3" />
       <option name="FOR_BRACE_FORCE" value="3" />
-      <option name="PARENT_SETTINGS_INSTALLED" value="true" />
       <indentOptions>
         <option name="INDENT_SIZE" value="2" />
         <option name="TAB_SIZE" value="2" />
@@ -232,10 +231,8 @@
       </indentOptions>
     </codeStyleSettings>
     <codeStyleSettings language="Python">
-      <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
       <option name="RIGHT_MARGIN" value="80" />
       <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
-      <option name="PARENT_SETTINGS_INSTALLED" value="true" />
       <indentOptions>
         <option name="INDENT_SIZE" value="2" />
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
diff --git a/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java b/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java
index b3335174700c..7cef1958589d 100644
--- a/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java
+++ b/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java
@@ -27,8 +27,9 @@
 import org.apache.ignite3.configuration.RootKey;
 import org.apache.ignite3.configuration.annotation.ConfigurationType;
 import org.apache.ignite3.configuration.validation.Validator;
-import org.apache.ignite3.internal.configuration.ConfigurationModules;
+import org.apache.ignite3.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite3.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite3.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite3.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite3.internal.configuration.storage.LocalFileConfigurationStorage;
 import org.apache.ignite3.internal.configuration.validation.ConfigurationValidator;
@@ -65,7 +66,7 @@ public static CombinedConfigRegistry loadCombinedRegistry(Path nodeCfgPath, Path
      * @param includeDefaults Include defaults.
      */
     public static ConfigurationRegistry loadNodeConfiguration(Path cfgPath, boolean includeDefaults) {
-        return loadConfigurations(cfgPath, ConfigurationModules.create(null).local(), includeDefaults);
+        return loadConfigurations(cfgPath, ConfigurationModulesImpl.create(null).local(), includeDefaults);
     }
 
     /**
@@ -77,7 +78,7 @@ public static ConfigurationRegistry loadNodeConfiguration(Path cfgPath, boolean
     public static ConfigurationRegistry loadClusterConfiguration(Path cfgPath, boolean includeDefaults) {
         // Hack so that it passes the validation
         // TODO: This is another hack that needs to be cleaned. We don't really need the ConfigurationRegistry.
-        var distributedModule = ConfigurationModules.create(null).distributed();
+        var distributedModule = ConfigurationModulesImpl.create(null).distributed();
         for (RootKey<?, ?, ?> key : distributedModule.rootKeys()) {
             try {
                 FieldUtils.writeDeclaredField(key, "storageType", ConfigurationType.LOCAL, true);
@@ -114,7 +115,8 @@ private static ConfigurationRegistry loadConfigurations(Path cfgPath, Configurat
         ConfigurationValidator localConfigurationValidator =
                 ConfigurationValidatorImpl.withDefaultValidators(localConfigurationGenerator, myValidators);
 
-        var nodeConfigRegistry = new ConfigurationRegistry(module.rootKeys(), localFileConfigurationStorage, localConfigurationGenerator,
+        var nodeConfigRegistry = new ConfigurationRegistryImpl(
+                module.rootKeys(), localFileConfigurationStorage, localConfigurationGenerator,
                 localConfigurationValidator, c -> {}, s -> false);
 
         nodeConfigRegistry.startAsync(new ComponentContext()).join();
diff --git a/modules/catalog-compaction/build.gradle b/modules/catalog-compaction/build.gradle
index 5dbee3015600..e605d7e4450d 100644
--- a/modules/catalog-compaction/build.gradle
+++ b/modules/catalog-compaction/build.gradle
@@ -23,9 +23,11 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 
 dependencies {
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.auto.service
 
     implementation project(':ignite-partition-distribution')
+    implementation libs.micronaut.inject
     implementation project(':ignite-catalog')
     implementation project(':ignite-cluster-management')
     implementation project(':ignite-distribution-zones')
diff --git a/modules/catalog-compaction/src/main/java/org/apache/ignite/internal/catalog/compaction/CatalogCompactionRunner.java b/modules/catalog-compaction/src/main/java/org/apache/ignite/internal/catalog/compaction/CatalogCompactionRunner.java
index c45215647705..baea1d701da5 100644
--- a/modules/catalog-compaction/src/main/java/org/apache/ignite/internal/catalog/compaction/CatalogCompactionRunner.java
+++ b/modules/catalog-compaction/src/main/java/org/apache/ignite/internal/catalog/compaction/CatalogCompactionRunner.java
@@ -22,12 +22,16 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
 import it.unimi.dsi.fastutil.ints.Int2IntMap.Entry;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMaps;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.objects.ObjectIterator;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.Collection;
@@ -60,6 +64,9 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProvider;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
@@ -114,6 +121,9 @@
  *     (at least, all partition owners are present in the logical topology), then the catalog is compacted.</li>
  * </ol>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(300)
 public class CatalogCompactionRunner implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(CatalogCompactionRunner.class);
 
@@ -170,6 +180,29 @@ public class CatalogCompactionRunner implements IgniteComponent {
 
     private volatile UUID localNodeId;
 
+    /** Constructor for DI. */
+    @Inject
+    public CatalogCompactionRunner(
+            NodeIdentity nodeIdentity,
+            CatalogManagerImpl catalogManager,
+            @Named("clusterMessaging") MessagingService messagingService,
+            LogicalTopologyService logicalTopologyService,
+            PlacementDriver placementDriver,
+            ReplicaService replicaService,
+            ClockService clockService,
+            SchemaSyncService schemaSyncService,
+            TopologyService topologyService,
+            LowWatermark lowWatermark,
+            ActiveLocalTxMinimumRequiredTimeProvider activeLocalTxMinimumRequiredTimeProvider,
+            MinimumRequiredTimeCollectorService minimumRequiredTimeCollectorService,
+            RebalanceMinimumRequiredTimeProvider rebalanceMinimumRequiredTimeProvider
+    ) {
+        this(nodeIdentity.nodeName(), catalogManager, messagingService, logicalTopologyService, placementDriver,
+                replicaService, clockService, schemaSyncService, topologyService, lowWatermark,
+                activeLocalTxMinimumRequiredTimeProvider, minimumRequiredTimeCollectorService,
+                rebalanceMinimumRequiredTimeProvider);
+    }
+
     /**
      * Constructs catalog compaction runner.
      */
diff --git a/modules/catalog/build.gradle b/modules/catalog/build.gradle
index c759e0870c77..48f53becedfa 100644
--- a/modules/catalog/build.gradle
+++ b/modules/catalog/build.gradle
@@ -24,9 +24,11 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-api')
     implementation project(':ignite-core')
+    implementation libs.micronaut.inject
     implementation project(':ignite-configuration')
     implementation project(':ignite-configuration-root')
     implementation project(':ignite-metastorage-api')
diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
index 827d4b82d6e5..864651a8211a 100644
--- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
+++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
@@ -28,8 +28,11 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.List;
@@ -37,6 +40,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.LongSupplier;
 import org.apache.ignite.internal.catalog.commands.CreateSchemaCommand;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogSchemaDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor;
@@ -48,7 +52,10 @@
 import org.apache.ignite.internal.catalog.storage.UpdateLog;
 import org.apache.ignite.internal.catalog.storage.UpdateLog.OnUpdateHandler;
 import org.apache.ignite.internal.catalog.storage.UpdateLogEvent;
+import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
 import org.apache.ignite.internal.catalog.storage.VersionedUpdate;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.event.AbstractEventProducer;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
@@ -59,6 +66,7 @@
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.sql.SqlCommon;
 import org.apache.ignite.internal.systemview.api.SystemView;
 import org.apache.ignite.internal.systemview.api.SystemViewProvider;
@@ -69,6 +77,9 @@
 /**
  * Catalog service implementation.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(100)
 public class CatalogManagerImpl extends AbstractEventProducer<CatalogEvent, CatalogEventParameters>
         implements CatalogManager, SystemViewProvider {
     private static final int MAX_RETRY_COUNT = 10;
@@ -118,6 +129,24 @@ public class CatalogManagerImpl extends AbstractEventProducer<CatalogEvent, Cata
      */
     private final PartitionCountCalculator partitionCountCalculator;
 
+    /** DI constructor that creates UpdateLogImpl internally and adapts configuration to suppliers. */
+    @Inject
+    public CatalogManagerImpl(
+            MetaStorageManager metaStorageManager,
+            ClockService clockService,
+            FailureProcessor failureProcessor,
+            SchemaSynchronizationConfiguration schemaSyncConfig,
+            PartitionCountCalculator partitionCountCalculator
+    ) {
+        this(
+                new UpdateLogImpl(metaStorageManager, failureProcessor),
+                clockService,
+                failureProcessor,
+                () -> schemaSyncConfig.delayDurationMillis().value(),
+                partitionCountCalculator
+        );
+    }
+
     /**
      * Constructor.
      */
diff --git a/modules/client/src/test/java/org/apache/ignite/client/TestServer.java b/modules/client/src/test/java/org/apache/ignite/client/TestServer.java
index e42878465f61..4fdfc8978f21 100644
--- a/modules/client/src/test/java/org/apache/ignite/client/TestServer.java
+++ b/modules/client/src/test/java/org/apache/ignite/client/TestServer.java
@@ -54,6 +54,7 @@
 import org.apache.ignite.internal.cluster.management.network.messages.CmgMessagesFactory;
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
@@ -189,7 +190,7 @@ public TestServer(
                 List.of(ClientConnectorExtensionConfigurationSchema.class, NetworkExtensionConfigurationSchema.class),
                 List.of(StaticNodeFinderConfigurationSchema.class, MulticastNodeFinderConfigurationSchema.class)
         );
-        cfg = new ConfigurationRegistry(
+        cfg = new ConfigurationRegistryImpl(
                 List.of(NodeConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/cluster-management/build.gradle b/modules/cluster-management/build.gradle
index b1ccf3346406..878a5cf608cc 100644
--- a/modules/cluster-management/build.gradle
+++ b/modules/cluster-management/build.gradle
@@ -46,6 +46,7 @@ dependencies {
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
 
     testImplementation project(':ignite-core')
     testImplementation project(':ignite-configuration')
@@ -74,6 +75,7 @@ dependencies {
     testFixturesImplementation testFixtures(project(':ignite-metrics'))
     testFixturesImplementation testFixtures(project(':ignite-raft'))
     testFixturesImplementation testFixtures(project(':ignite-failure-handler'))
+    testFixturesImplementation libs.micronaut.inject
 
     integrationTestAnnotationProcessor libs.micronaut.inject.annotation.processor
     integrationTestImplementation project(':ignite-rest')
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterInitializer.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterInitializer.java
index 3393e5c85946..e62ef5908cbb 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterInitializer.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterInitializer.java
@@ -21,6 +21,8 @@
 import static java.util.stream.Collectors.toUnmodifiableSet;
 import static org.apache.ignite.internal.lang.IgniteStringFormatter.format;
 
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
@@ -55,6 +57,7 @@
 /**
  * Class for performing cluster initialization.
  */
+@Singleton
 public class ClusterInitializer {
     private static final IgniteLogger LOG = Loggers.forClass(ClusterInitializer.class);
 
@@ -72,7 +75,7 @@ public class ClusterInitializer {
     public ClusterInitializer(
             ClusterService clusterService,
             ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher,
-            ConfigurationValidator clusterConfigurationValidator
+            @Named("distributed") ConfigurationValidator clusterConfigurationValidator
     ) {
         this.clusterService = clusterService;
         this.configurationDynamicDefaultsPatcher = configurationDynamicDefaultsPatcher;
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterManagementGroupManager.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterManagementGroupManager.java
index 45a0b6ecf319..f37125288f60 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterManagementGroupManager.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterManagementGroupManager.java
@@ -31,6 +31,10 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Rest.CLUSTER_NOT_INIT_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
@@ -71,6 +75,8 @@
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopology;
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.message.ResetClusterMessage;
 import org.apache.ignite.internal.disaster.system.storage.ClusterResetStorage;
 import org.apache.ignite.internal.event.AbstractEventProducer;
@@ -115,6 +121,9 @@
  * <a href="https://cwiki.apache.org/confluence/display/IGNITE/IEP-77%3A+Node+Join+Protocol+and+Initialization+for+Ignite+3">IEP-77</a>
  * for the description of the Cluster Management Group and its responsibilities.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1900)
 public class ClusterManagementGroupManager extends AbstractEventProducer<ClusterManagerGroupEvent, EventParameters>
         implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(ClusterManagementGroupManager.class);
@@ -193,6 +202,7 @@ public class ClusterManagementGroupManager extends AbstractEventProducer<Cluster
     private final Consumer<RaftGroupConfiguration> onConfigurationCommittedListener;
 
     /** Constructor. */
+    @Inject
     public ClusterManagementGroupManager(
             VaultManager vault,
             ClusterResetStorage clusterResetStorage,
@@ -205,7 +215,7 @@ public ClusterManagementGroupManager(
             NodeAttributes nodeAttributes,
             FailureProcessor failureProcessor,
             ClusterIdStore clusterIdStore,
-            RaftGroupOptionsConfigurer raftGroupOptionsConfigurer,
+            @Named("cmg") RaftGroupOptionsConfigurer raftGroupOptionsConfigurer,
             MetricManager metricManager
     ) {
         this(
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/NodeAttributesCollector.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/NodeAttributesCollector.java
index 6d67ef123d16..119f12b8caf3 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/NodeAttributesCollector.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/NodeAttributesCollector.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.cluster.management;
 
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -32,6 +33,7 @@
  * This class is responsible for retrieving local node attributes
  * from system components before the local node joins the cluster.
  */
+@Singleton
 public class NodeAttributesCollector implements NodeAttributes {
     private final List<NodeAttributesProvider> systemAttributesProviders = new ArrayList<>();
 
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ClusterStateStorageManager.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ClusterStateStorageManager.java
index 895cec946060..04c409e3df04 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ClusterStateStorageManager.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ClusterStateStorageManager.java
@@ -22,6 +22,7 @@
 import static org.apache.ignite.internal.util.ByteUtils.longToBytes;
 import static org.apache.ignite.internal.util.ByteUtils.uuidToBytes;
 
+import jakarta.inject.Singleton;
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.List;
@@ -37,6 +38,7 @@
 /**
  * A wrapper around a {@link ClusterStateStorage} which provides convenient methods.
  */
+@Singleton
 public class ClusterStateStorageManager {
     /** Storage key for the CMG state. */
     private static final byte[] CMG_STATE_KEY = "cmg_state".getBytes(UTF_8);
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/RocksDbClusterStateStorage.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/RocksDbClusterStateStorage.java
index cbc6f8360753..e77b0dc0e2fc 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/RocksDbClusterStateStorage.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/RocksDbClusterStateStorage.java
@@ -23,6 +23,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -36,6 +40,10 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiFunction;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -58,6 +66,9 @@
 /**
  * {@link ClusterStateStorage} implementation based on RocksDB.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(700)
 public class RocksDbClusterStateStorage implements ClusterStateStorage {
     private static final IgniteLogger LOG = Loggers.forClass(RocksDbClusterStateStorage.class);
 
@@ -85,6 +96,14 @@ public class RocksDbClusterStateStorage implements ClusterStateStorage {
     /** Prevents double stopping of the component. */
     private final AtomicBoolean stopGuard = new AtomicBoolean();
 
+    /**
+     * Creates a new instance using DI-provided dependencies.
+     */
+    @Inject
+    public RocksDbClusterStateStorage(@Named("cmg") ComponentWorkingDir cmgWorkDir, NodeIdentity nodeIdentity) {
+        this(cmgWorkDir.dbPath(), nodeIdentity.nodeName());
+    }
+
     /**
      * Creates a new instance.
      *
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ValidationManager.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ValidationManager.java
index 35b3bad60971..21b670f3f8e8 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ValidationManager.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ValidationManager.java
@@ -20,6 +20,7 @@
 import static java.util.stream.Collectors.toSet;
 import static org.apache.ignite.internal.lang.IgniteSystemProperties.COLOCATION_FEATURE_FLAG;
 
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.Set;
@@ -41,6 +42,7 @@
  * After the node finishes local recovery procedures, it sends a {@link JoinReadyCommand} containing the validation token. If the local
  * token and the received token match, the node will be added to the logical topology and the token will be invalidated.
  */
+@Singleton
 public class ValidationManager {
     protected final ClusterStateStorageManager storageManager;
 
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyImpl.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyImpl.java
index 855a695fb7b2..a333e960e442 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyImpl.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyImpl.java
@@ -24,6 +24,7 @@
 import static java.util.stream.Collectors.toMap;
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -49,6 +50,7 @@
 /**
  * Implementation of {@link LogicalTopology}.
  */
+@Singleton
 public class LogicalTopologyImpl implements LogicalTopology {
     private static final IgniteLogger LOG = Loggers.forClass(LogicalTopologyImpl.class);
 
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyServiceImpl.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyServiceImpl.java
index afb212043fbc..9fefb2d4ef42 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyServiceImpl.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyServiceImpl.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.cluster.management.topology;
 
+import jakarta.inject.Singleton;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
@@ -28,6 +29,7 @@
 /**
  * {@link LogicalTopologyService} implementation.
  */
+@Singleton
 public class LogicalTopologyServiceImpl implements LogicalTopologyService {
     private final LogicalTopology logicalTopology;
 
diff --git a/modules/cluster-metrics/build.gradle b/modules/cluster-metrics/build.gradle
index 5bbf01c091f2..f795b2c4604c 100644
--- a/modules/cluster-metrics/build.gradle
+++ b/modules/cluster-metrics/build.gradle
@@ -22,9 +22,11 @@ description = 'ignite-cluster-metrics'
 
 dependencies {
     annotationProcessor project(":ignite-network-annotation-processor")
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-core')
     implementation project(':ignite-metrics')
     implementation project(':ignite-network')
     implementation libs.jetbrains.annotations
+    implementation libs.micronaut.inject
 }
diff --git a/modules/cluster-metrics/src/main/java/org/apache/ignite/internal/metrics/messaging/MetricMessaging.java b/modules/cluster-metrics/src/main/java/org/apache/ignite/internal/metrics/messaging/MetricMessaging.java
index 9ea0360f3640..108b9703253c 100644
--- a/modules/cluster-metrics/src/main/java/org/apache/ignite/internal/metrics/messaging/MetricMessaging.java
+++ b/modules/cluster-metrics/src/main/java/org/apache/ignite/internal/metrics/messaging/MetricMessaging.java
@@ -26,6 +26,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -33,6 +37,8 @@
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -55,6 +61,9 @@
 /**
  * Metrics messaging service.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1000)
 public class MetricMessaging implements IgniteComponent {
     private static final long NETWORK_TIMEOUT_MILLIS = Long.MAX_VALUE;
 
@@ -75,7 +84,12 @@ public class MetricMessaging implements IgniteComponent {
      * @param messagingService Messaging service.
      * @param topologyService Topology service.
      */
-    public MetricMessaging(MetricManager metricManager, MessagingService messagingService, TopologyService topologyService) {
+    @Inject
+    public MetricMessaging(
+            MetricManager metricManager,
+            @Named("clusterMessaging") MessagingService messagingService,
+            TopologyService topologyService
+    ) {
         this.metricManager = metricManager;
         this.messagingService = messagingService;
         this.topologyService = topologyService;
diff --git a/modules/code-deployment-classloader/build.gradle b/modules/code-deployment-classloader/build.gradle
index 71c0f79c1e83..bdbf0d8bb053 100644
--- a/modules/code-deployment-classloader/build.gradle
+++ b/modules/code-deployment-classloader/build.gradle
@@ -23,6 +23,9 @@ apply from: 'jobs.gradle'
 description = 'ignite-code-deployment-classloader'
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
 
     implementation project(':ignite-core')
diff --git a/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsClassLoaderFactory.java b/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsClassLoaderFactory.java
index 9496f5ccd7b7..fe7a06e77425 100644
--- a/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsClassLoaderFactory.java
+++ b/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsClassLoaderFactory.java
@@ -17,12 +17,14 @@
 
 package org.apache.ignite.internal.deployunit.loader;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import org.apache.ignite.internal.deployunit.DisposableDeploymentUnit;
 
 /**
  * Deployment units classloader factory.
  */
+@Singleton
 public class UnitsClassLoaderFactory {
     /**
      * Create a class loader for the specified units.
diff --git a/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsContextManager.java b/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsContextManager.java
index bbcc1caee981..b169b6a69809 100644
--- a/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsContextManager.java
+++ b/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsContextManager.java
@@ -22,6 +22,7 @@
 import static org.apache.ignite.internal.deployunit.loader.ClassLoaderExceptionsMapper.mapClassLoaderExceptions;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
@@ -44,6 +45,7 @@
 /**
  * Manages job context.
  */
+@Singleton
 public class UnitsContextManager {
     private static final IgniteLogger LOG = Loggers.forClass(UnitsContextManager.class);
 
diff --git a/modules/code-deployment/build.gradle b/modules/code-deployment/build.gradle
index b275bf4b4af4..6831697fe493 100644
--- a/modules/code-deployment/build.gradle
+++ b/modules/code-deployment/build.gradle
@@ -26,8 +26,10 @@ description = 'ignite-code-deployment'
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.auto.service
 
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
     implementation project(':ignite-core')
diff --git a/modules/code-deployment/src/main/java/org/apache/ignite/internal/deployunit/metastore/DeploymentUnitStoreImpl.java b/modules/code-deployment/src/main/java/org/apache/ignite/internal/deployunit/metastore/DeploymentUnitStoreImpl.java
index 974c5dd2df79..ba676449caef 100644
--- a/modules/code-deployment/src/main/java/org/apache/ignite/internal/deployunit/metastore/DeploymentUnitStoreImpl.java
+++ b/modules/code-deployment/src/main/java/org/apache/ignite/internal/deployunit/metastore/DeploymentUnitStoreImpl.java
@@ -28,6 +28,7 @@
 import static org.apache.ignite.internal.metastorage.dsl.Operations.remove;
 import static org.apache.ignite.internal.util.CompletableFutures.falseCompletedFuture;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
@@ -52,6 +53,7 @@
 /**
  * Implementation of {@link DeploymentUnitStore} based on {@link MetaStorageManager}.
  */
+@Singleton
 public class DeploymentUnitStoreImpl implements DeploymentUnitStore {
     private static final IgniteLogger LOG = Loggers.forClass(DeploymentUnitStoreImpl.class);
 
diff --git a/modules/compute/build.gradle b/modules/compute/build.gradle
index 0be2d5189ff3..e1e045336e6c 100644
--- a/modules/compute/build.gradle
+++ b/modules/compute/build.gradle
@@ -22,6 +22,8 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 apply from: 'jobs.gradle'
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     implementation project(':ignite-api')
     implementation project(':ignite-network')
     implementation project(':ignite-table')
@@ -38,6 +40,7 @@ dependencies {
     implementation project(':ignite-system-view-api')
     implementation project(':ignite-security-api')
     implementation project(':ignite-eventlog')
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.auto.service.annotations
diff --git a/modules/compute/src/main/java/org/apache/ignite/internal/compute/ComputeComponentImpl.java b/modules/compute/src/main/java/org/apache/ignite/internal/compute/ComputeComponentImpl.java
index ab6e966b0197..666da561d218 100644
--- a/modules/compute/src/main/java/org/apache/ignite/internal/compute/ComputeComponentImpl.java
+++ b/modules/compute/src/main/java/org/apache/ignite/internal/compute/ComputeComponentImpl.java
@@ -22,6 +22,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.List;
 import java.util.UUID;
@@ -34,6 +38,9 @@
 import org.apache.ignite.compute.JobState;
 import org.apache.ignite.deployment.DeploymentUnit;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
 import org.apache.ignite.internal.compute.events.ComputeEventMetadataBuilder;
 import org.apache.ignite.internal.compute.executor.ComputeExecutor;
@@ -69,6 +76,9 @@
 /**
  * Implementation of {@link ComputeComponent}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1200)
 public class ComputeComponentImpl implements ComputeComponent, SystemViewProvider {
     private static final IgniteLogger LOG = Loggers.forClass(ComputeComponentImpl.class);
 
@@ -100,6 +110,23 @@ public class ComputeComponentImpl implements ComputeComponent, SystemViewProvide
 
     private final ComputeViewProvider computeViewProvider = new ComputeViewProvider();
 
+    /** Constructor for DI. */
+    @Inject
+    public ComputeComponentImpl(
+            NodeIdentity nodeIdentity,
+            @Named("clusterMessaging") MessagingService messagingService,
+            TopologyService topologyService,
+            LogicalTopologyService logicalTopologyService,
+            UnitsContextManager jobContextManager,
+            ComputeExecutor executor,
+            ComputeConfiguration computeConfiguration,
+            EventLog eventLog,
+            HybridTimestampTracker observableTimestampTracker
+    ) {
+        this(nodeIdentity.nodeName(), messagingService, topologyService, logicalTopologyService,
+                jobContextManager, executor, computeConfiguration, eventLog, observableTimestampTracker);
+    }
+
     /**
      * Creates a new instance.
      */
diff --git a/modules/compute/src/main/java/org/apache/ignite/internal/compute/IgniteComputeImpl.java b/modules/compute/src/main/java/org/apache/ignite/internal/compute/IgniteComputeImpl.java
index 533f0b927a4e..f4d384e1f684 100644
--- a/modules/compute/src/main/java/org/apache/ignite/internal/compute/IgniteComputeImpl.java
+++ b/modules/compute/src/main/java/org/apache/ignite/internal/compute/IgniteComputeImpl.java
@@ -27,6 +27,9 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.unwrapCause;
 import static org.apache.ignite.lang.ErrorGroups.Compute.COMPUTE_JOB_FAILED_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
@@ -63,6 +66,9 @@
 import org.apache.ignite.compute.task.TaskExecution;
 import org.apache.ignite.deployment.DeploymentUnit;
 import org.apache.ignite.internal.client.proto.StreamerReceiverSerializer;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.events.ComputeEventMetadata;
 import org.apache.ignite.internal.compute.events.ComputeEventMetadata.Type;
 import org.apache.ignite.internal.compute.events.ComputeEventMetadataBuilder;
@@ -99,6 +105,9 @@
 /**
  * Implementation of {@link IgniteCompute}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1300)
 public class IgniteComputeImpl implements IgniteComputeInternal, StreamerReceiverRunner {
     private final String nodeName;
 
@@ -114,6 +123,20 @@ public class IgniteComputeImpl implements IgniteComputeInternal, StreamerReceive
 
     private final HybridTimestampTracker observableTimestampTracker;
 
+    /** Constructor for DI. */
+    @Inject
+    public IgniteComputeImpl(
+            NodeIdentity nodeIdentity,
+            PlacementDriver placementDriver,
+            TopologyService topologyService,
+            IgniteTablesInternal tables,
+            ComputeComponent computeComponent,
+            HybridClock clock,
+            HybridTimestampTracker observableTimestampTracker
+    ) {
+        this(nodeIdentity.nodeName(), placementDriver, topologyService, tables, computeComponent, clock, observableTimestampTracker);
+    }
+
     /**
      * Create new instance.
      */
diff --git a/modules/compute/src/main/java/org/apache/ignite/internal/compute/executor/ComputeExecutorImpl.java b/modules/compute/src/main/java/org/apache/ignite/internal/compute/executor/ComputeExecutorImpl.java
index da589a472947..28957359f9de 100644
--- a/modules/compute/src/main/java/org/apache/ignite/internal/compute/executor/ComputeExecutorImpl.java
+++ b/modules/compute/src/main/java/org/apache/ignite/internal/compute/executor/ComputeExecutorImpl.java
@@ -24,6 +24,10 @@
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_READ;
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_WRITE;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
 import java.nio.file.Path;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
@@ -34,6 +38,8 @@
 import org.apache.ignite.compute.JobExecutorType;
 import org.apache.ignite.compute.task.MapReduceTask;
 import org.apache.ignite.compute.task.TaskExecutionContext;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.ComputeJobDataHolder;
 import org.apache.ignite.internal.compute.ComputeJobDataType;
 import org.apache.ignite.internal.compute.ComputeUtils;
@@ -63,6 +69,9 @@
 /**
  * Base implementation of {@link ComputeExecutor}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1100)
 public class ComputeExecutorImpl implements ComputeExecutor {
     private static final IgniteLogger LOG = Loggers.forClass(ComputeExecutorImpl.class);
 
@@ -82,6 +91,19 @@ public class ComputeExecutorImpl implements ComputeExecutor {
 
     private @Nullable DotNetComputeExecutor dotNetComputeExecutor;
 
+    /** Constructor for DI. */
+    @Inject
+    public ComputeExecutorImpl(
+            Provider<Ignite> igniteProvider,
+            ComputeStateMachine stateMachine,
+            ComputeConfiguration configuration,
+            TopologyService topologyService,
+            ClockService clockService,
+            EventLog eventLog
+    ) {
+        this(igniteProvider.get(), stateMachine, configuration, topologyService, clockService, eventLog);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/compute/src/main/java/org/apache/ignite/internal/compute/state/InMemoryComputeStateMachine.java b/modules/compute/src/main/java/org/apache/ignite/internal/compute/state/InMemoryComputeStateMachine.java
index cfab1d1362cd..a77c2008caa1 100644
--- a/modules/compute/src/main/java/org/apache/ignite/internal/compute/state/InMemoryComputeStateMachine.java
+++ b/modules/compute/src/main/java/org/apache/ignite/internal/compute/state/InMemoryComputeStateMachine.java
@@ -24,6 +24,8 @@
 import static org.apache.ignite.compute.JobStatus.FAILED;
 import static org.apache.ignite.compute.JobStatus.QUEUED;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.time.Instant;
 import java.util.Map;
 import java.util.UUID;
@@ -31,6 +33,7 @@
 import java.util.function.Function;
 import org.apache.ignite.compute.JobState;
 import org.apache.ignite.compute.JobStatus;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.compute.Cleaner;
 import org.apache.ignite.internal.compute.JobStateImpl;
 import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
@@ -40,6 +43,7 @@
 /**
  * In memory implementation of {@link ComputeStateMachine}.
  */
+@Singleton
 public class InMemoryComputeStateMachine implements ComputeStateMachine {
     private static final IgniteLogger LOG = Loggers.forClass(InMemoryComputeStateMachine.class);
 
@@ -51,6 +55,12 @@ public class InMemoryComputeStateMachine implements ComputeStateMachine {
 
     private final Map<UUID, JobState> states = new ConcurrentHashMap<>();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public InMemoryComputeStateMachine(ComputeConfiguration configuration, NodeIdentity nodeIdentity) {
+        this(configuration, nodeIdentity.nodeName());
+    }
+
     public InMemoryComputeStateMachine(ComputeConfiguration configuration, String nodeName) {
         this.configuration = configuration;
         this.nodeName = nodeName;
diff --git a/modules/compute/src/test/java/org/apache/ignite/internal/compute/IgniteComputeImplTest.java b/modules/compute/src/test/java/org/apache/ignite/internal/compute/IgniteComputeImplTest.java
index 9a03d799016f..60eb57dafa76 100644
--- a/modules/compute/src/test/java/org/apache/ignite/internal/compute/IgniteComputeImplTest.java
+++ b/modules/compute/src/test/java/org/apache/ignite/internal/compute/IgniteComputeImplTest.java
@@ -54,6 +54,7 @@
 import org.apache.ignite.compute.JobTarget;
 import org.apache.ignite.deployment.DeploymentUnit;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
@@ -87,6 +88,9 @@
 class IgniteComputeImplTest extends BaseIgniteAbstractTest {
     private static final String JOB_CLASS_NAME = "org.example.SimpleJob";
 
+    @Mock
+    private NodeIdentity nodeIdentity;
+
     @Mock
     private TopologyService topologyService;
 
diff --git a/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java
new file mode 100644
index 000000000000..1a7b5fc2e98b
--- /dev/null
+++ b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration;
+
+import org.apache.ignite.configuration.ConfigurationModule;
+import org.apache.ignite.configuration.annotation.ConfigurationType;
+
+/**
+ * An ensemble of {@link ConfigurationModule}s used to easily pick node-local and cluster-wide configuration
+ * and merge modules for convenience.
+ */
+public interface ConfigurationModules {
+    /**
+     * Return a module representing the result of merge of modules of type
+     * {@link ConfigurationType#LOCAL}.
+     *
+     * @return node-local configuration merge result
+     */
+    ConfigurationModule local();
+
+    /**
+     * Return a module representing the result of merge of modules of type
+     * {@link ConfigurationType#DISTRIBUTED}.
+     *
+     * @return cluster-wide configuration merge result
+     */
+    ConfigurationModule distributed();
+}
diff --git a/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java
new file mode 100644
index 000000000000..7431d406c20a
--- /dev/null
+++ b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+import org.apache.ignite.configuration.ConfigurationTree;
+import org.apache.ignite.configuration.KeyIgnorer;
+import org.apache.ignite.configuration.RootKey;
+import org.apache.ignite.configuration.SuperRootChange;
+import org.apache.ignite.internal.configuration.tree.ConfigurationSource;
+import org.apache.ignite.internal.manager.IgniteComponent;
+
+/**
+ * Configuration registry interface.
+ */
+public interface ConfigurationRegistry extends IgniteComponent {
+    /**
+     * Gets the public configuration tree.
+     *
+     * @param rootKey Root key.
+     * @param <V> View type.
+     * @param <C> Change type.
+     * @param <T> Configuration tree type.
+     * @return Public configuration tree.
+     */
+    <V, C extends V, T extends ConfigurationTree<? super V, ? super C>> T getConfiguration(RootKey<T, V, C> rootKey);
+
+    /**
+     * Returns a future that resolves after the defaults are persisted to the storage.
+     */
+    CompletableFuture<Void> onDefaultsPersisted();
+
+    /**
+     * Change configuration. Gives the possibility to atomically update several root trees.
+     *
+     * @param change Closure that would consume a mutable super root instance.
+     * @return Future that is completed on change completion.
+     */
+    CompletableFuture<Void> change(Consumer<SuperRootChange> change);
+
+    /**
+     * Change configuration.
+     *
+     * @param changesSrc Configuration source to create patch from it.
+     * @return Future that is completed on change completion.
+     */
+    CompletableFuture<Void> change(ConfigurationSource changesSrc);
+
+    /**
+     * Initializes the configuration with the given source. This method should be used only for the initial setup of the configuration. The
+     * configuration is initialized with the provided source only if the storage is empty, and it is saved along with the defaults. This
+     * method must be called before {@link #startAsync}.
+     *
+     * @param configurationSource the configuration source to initialize with.
+     */
+    void initializeConfigurationWith(ConfigurationSource configurationSource);
+
+    /**
+     * Determines if key should be ignored.
+     */
+    KeyIgnorer keyIgnorer();
+
+    /**
+     * Returns the count of configuration listener notifications.
+     *
+     * <p>Monotonically increasing value that should be incremented each time an attempt is made to notify all listeners of the
+     * configuration. Allows to guarantee that new listeners will be called only on the next notification of all configuration listeners.
+     */
+    long notificationCount();
+}
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/ConfigurationSource.java b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/tree/ConfigurationSource.java
similarity index 100%
rename from modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/ConfigurationSource.java
rename to modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/tree/ConfigurationSource.java
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/ConstructableTreeNode.java b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/tree/ConstructableTreeNode.java
similarity index 100%
rename from modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/ConstructableTreeNode.java
rename to modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/tree/ConstructableTreeNode.java
diff --git a/modules/configuration-presentation/src/main/java/org/apache/ignite/internal/configuration/presentation/HoconPresentation.java b/modules/configuration-presentation/src/main/java/org/apache/ignite/internal/configuration/presentation/HoconPresentation.java
index b0024153cb0d..478292888b81 100644
--- a/modules/configuration-presentation/src/main/java/org/apache/ignite/internal/configuration/presentation/HoconPresentation.java
+++ b/modules/configuration-presentation/src/main/java/org/apache/ignite/internal/configuration/presentation/HoconPresentation.java
@@ -26,6 +26,7 @@
 import org.apache.ignite.configuration.ConfigurationChangeException;
 import org.apache.ignite.configuration.validation.ConfigurationValidationException;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.exception.ConfigurationApplyException;
 import org.apache.ignite.internal.configuration.exception.ConfigurationParseException;
 import org.apache.ignite.internal.configuration.exception.ConfigurationValidationIgniteException;
@@ -59,8 +60,10 @@ public String represent() {
     /** {@inheritDoc} */
     @Override
     public String representByPath(@Nullable String path) {
-        return HoconConverter.represent(registry.superRoot(), path == null ? List.of() : ConfigurationUtil.split(path)).render(
-                ConfigRenderOptions.concise());
+        List<String> pathList = path == null ? List.of() : ConfigurationUtil.split(path);
+
+        return HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), pathList)
+                .render(ConfigRenderOptions.concise());
     }
 
     /** {@inheritDoc} */
diff --git a/modules/configuration-presentation/src/test/java/org/apache/ignite/internal/configuration/presentation/HoconPresentationTest.java b/modules/configuration-presentation/src/test/java/org/apache/ignite/internal/configuration/presentation/HoconPresentationTest.java
index 7a75c25562bd..3faf3364ee91 100644
--- a/modules/configuration-presentation/src/test/java/org/apache/ignite/internal/configuration/presentation/HoconPresentationTest.java
+++ b/modules/configuration-presentation/src/test/java/org/apache/ignite/internal/configuration/presentation/HoconPresentationTest.java
@@ -41,6 +41,7 @@
 import org.apache.ignite.configuration.validation.ValidationIssue;
 import org.apache.ignite.configuration.validation.Validator;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.exception.ConfigurationApplyException;
 import org.apache.ignite.internal.configuration.exception.ConfigurationParseException;
@@ -86,7 +87,7 @@ public void validate(Value annotation, ValidationContext<Object> ctx) {
 
         generator = new ConfigurationTreeGenerator(TestRootConfiguration.KEY);
 
-        cfgRegistry = new ConfigurationRegistry(
+        cfgRegistry = new ConfigurationRegistryImpl(
                 List.of(TestRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/configuration-storage/build.gradle b/modules/configuration-storage/build.gradle
index bf1f6da720f2..004d47199275 100644
--- a/modules/configuration-storage/build.gradle
+++ b/modules/configuration-storage/build.gradle
@@ -22,8 +22,10 @@ apply from: "$rootDir/buildscripts/publishing.gradle"
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-metastorage-api')
+    implementation libs.micronaut.inject
     implementation project(':ignite-configuration-api')
     implementation project(':ignite-configuration')
     implementation project(':ignite-core')
diff --git a/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java b/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java
index 90c4b5d5c83f..c73e0959721a 100644
--- a/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java
+++ b/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java
@@ -23,6 +23,8 @@
 import static org.apache.ignite.internal.util.CompletableFutures.falseCompletedFuture;
 import static org.apache.ignite.internal.util.StringUtils.toStringWithoutPrefix;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -36,6 +38,7 @@
 import java.util.concurrent.Flow.Subscription;
 import java.util.concurrent.TimeUnit;
 import org.apache.ignite.configuration.annotation.ConfigurationType;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.configuration.util.ConfigurationSerializationUtil;
 import org.apache.ignite.internal.future.InFlightFutures;
 import org.apache.ignite.internal.lang.ByteArray;
@@ -55,6 +58,7 @@
 /**
  * Distributed configuration storage.
  */
+@Singleton
 public class DistributedConfigurationStorage implements ConfigurationStorage {
     /** Logger. */
     private static final IgniteLogger LOG = Loggers.forClass(DistributedConfigurationStorage.class);
@@ -93,6 +97,12 @@ public class DistributedConfigurationStorage implements ConfigurationStorage {
 
     private final InFlightFutures futureTracker = new InFlightFutures();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public DistributedConfigurationStorage(NodeIdentity nodeIdentity, MetaStorageManager metaStorageManager) {
+        this(nodeIdentity.nodeName(), metaStorageManager);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/configuration/build.gradle b/modules/configuration/build.gradle
index f0f77c6676cb..9fe05c4798ae 100644
--- a/modules/configuration/build.gradle
+++ b/modules/configuration/build.gradle
@@ -29,8 +29,11 @@ dependencies {
     implementation project(':ignite-bytecode')
     implementation project(':ignite-core')
     implementation libs.jetbrains.annotations
+    implementation libs.micronaut.inject
     implementation libs.typesafe.config
 
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     testAnnotationProcessor project(':ignite-configuration-annotation-processor')
     testImplementation project(':ignite-core')
     testImplementation testFixtures(project(':ignite-core'))
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/CompoundModule.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/CompoundModule.java
similarity index 100%
rename from modules/runner/src/main/java/org/apache/ignite/internal/configuration/CompoundModule.java
rename to modules/configuration/src/main/java/org/apache/ignite/internal/configuration/CompoundModule.java
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationDynamicDefaultsPatcherImpl.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationDynamicDefaultsPatcherImpl.java
index ab6cb4e4f54f..ed26c0227e69 100644
--- a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationDynamicDefaultsPatcherImpl.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationDynamicDefaultsPatcherImpl.java
@@ -20,6 +20,9 @@
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 import com.typesafe.config.ConfigRenderOptions;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.List;
 import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
 import org.apache.ignite.configuration.ConfigurationModule;
@@ -33,6 +36,7 @@
 /**
  * Implementation of {@link ConfigurationDynamicDefaultsPatcher}.
  */
+@Singleton
 public class ConfigurationDynamicDefaultsPatcherImpl implements ConfigurationDynamicDefaultsPatcher {
     /**
      * Configuration module.
@@ -52,6 +56,14 @@ public ConfigurationDynamicDefaultsPatcherImpl(
         this.generator = generator;
     }
 
+    @Inject
+    public ConfigurationDynamicDefaultsPatcherImpl(
+            ConfigurationModules modules,
+            @Named("distributed") ConfigurationTreeGenerator generator
+    ) {
+        this(modules.distributed(), generator);
+    }
+
     @Override
     public String patchWithDynamicDefaults(String hocon) {
         SuperRoot superRoot = convertToSuperRoot(hocon);
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java
similarity index 71%
rename from modules/runner/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java
rename to modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java
index 9b1132b8aac0..74f2d8a642ba 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java
@@ -19,46 +19,51 @@
 
 import static java.util.stream.Collectors.toUnmodifiableList;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.List;
 import java.util.ServiceLoader;
 import java.util.ServiceLoader.Provider;
 import org.apache.ignite.configuration.ConfigurationModule;
 import org.apache.ignite.configuration.annotation.ConfigurationType;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.jetbrains.annotations.Nullable;
 
 /**
- * An ensemble of {@link ConfigurationModule}s used to easily pick node-local and cluster-wide configuration
- * and merge modules for convenience.
+ * Implementation of {@link ConfigurationModules} that loads and merges {@link ConfigurationModule}s.
  */
-public class ConfigurationModules {
+@Singleton
+public class ConfigurationModulesImpl implements ConfigurationModules {
     private final CompoundModule localCompound;
     private final CompoundModule distributedCompound;
 
     /**
-     * Creates a new instance of {@link ConfigurationModules} wrapping modules passed to it.
+     * Creates a new instance wrapping modules passed to it.
      *
      * @param modules modules to wrap; they may be of different types
      */
-    public ConfigurationModules(List<ConfigurationModule> modules) {
+    public ConfigurationModulesImpl(List<ConfigurationModule> modules) {
         localCompound = compoundOfType(ConfigurationType.LOCAL, modules);
         distributedCompound = compoundOfType(ConfigurationType.DISTRIBUTED, modules);
     }
 
     /**
-     * Return a module representing the result of merge of modules of type {@link ConfigurationType#LOCAL}.
+     * DI constructor that discovers configuration modules using the service provider class loader from {@link NodeIdentity}.
      *
-     * @return node-local configuration merge result
+     * @param nodeIdentity Node identity providing the service provider class loader.
      */
+    @Inject
+    public ConfigurationModulesImpl(NodeIdentity nodeIdentity) {
+        this(loadModules(nodeIdentity.serviceProviderClassLoader()));
+    }
+
+    @Override
     public ConfigurationModule local() {
         return localCompound;
     }
 
-    /**
-     * Return a module representing the result of merge of modules of type {@link ConfigurationType#DISTRIBUTED}.
-     *
-     * @return cluster-wide configuration merge result
-     */
+    @Override
     public ConfigurationModule distributed() {
         return distributedCompound;
     }
@@ -76,7 +81,11 @@ private static CompoundModule compoundOfType(ConfigurationType type, Collection<
      * @param classLoader the class loader to use.
      * @return Configuration modules.
      */
-    public static ConfigurationModules create(@Nullable ClassLoader classLoader) {
+    public static ConfigurationModulesImpl create(@Nullable ClassLoader classLoader) {
+        return new ConfigurationModulesImpl(loadModules(classLoader));
+    }
+
+    private static List<ConfigurationModule> loadModules(@Nullable ClassLoader classLoader) {
         List<ConfigurationModule> modules = ServiceLoader.load(ConfigurationModule.class, classLoader).stream()
                 .map(Provider::get)
                 .collect(toUnmodifiableList());
@@ -86,6 +95,6 @@ public static ConfigurationModules create(@Nullable ClassLoader classLoader) {
                     + "Please make sure that the classloader for loading services is correct.");
         }
 
-        return new ConfigurationModules(modules);
+        return modules;
     }
 }
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistryImpl.java
similarity index 96%
rename from modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java
rename to modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistryImpl.java
index 4da72657fdb1..ec79f6f3612f 100644
--- a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistryImpl.java
@@ -45,16 +45,15 @@
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
-import org.apache.ignite.internal.manager.IgniteComponent;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 
 /**
- * Configuration registry.
+ * Configuration registry implementation.
  */
-public class ConfigurationRegistry implements IgniteComponent {
+public class ConfigurationRegistryImpl implements ConfigurationRegistry {
     /** The logger. */
-    private static final IgniteLogger LOG = Loggers.forClass(ConfigurationRegistry.class);
+    private static final IgniteLogger LOG = Loggers.forClass(ConfigurationRegistryImpl.class);
 
     /** Generated configuration implementations. Mapping: {@link RootKey#key} -> configuration implementation. */
     private final Map<String, DynamicConfiguration<?, ?>> configs = new HashMap<>();
@@ -67,7 +66,7 @@ public class ConfigurationRegistry implements IgniteComponent {
 
     /** Constructor. */
     @TestOnly
-    public ConfigurationRegistry(
+    public ConfigurationRegistryImpl(
             Collection<RootKey<?, ?, ?>> rootKeys,
             ConfigurationStorage storage,
             ConfigurationTreeGenerator generator,
@@ -79,7 +78,7 @@ public ConfigurationRegistry(
     /**
      * Constructor.
      */
-    public ConfigurationRegistry(
+    public ConfigurationRegistryImpl(
             Collection<RootKey<?, ?, ?>> rootKeys,
             ConfigurationStorage storage,
             ConfigurationTreeGenerator generator,
@@ -132,6 +131,7 @@ public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
     /**
      * Returns a future that resolves after the defaults are persisted to the storage.
      */
+    @Override
     public CompletableFuture<Void> onDefaultsPersisted() {
         return changer.onDefaultsPersisted();
     }
@@ -143,6 +143,7 @@ public CompletableFuture<Void> onDefaultsPersisted() {
      *
      * @param configurationSource the configuration source to initialize with.
      */
+    @Override
     public void initializeConfigurationWith(ConfigurationSource configurationSource) {
         changer.initializeConfigurationWith(configurationSource);
     }
@@ -156,6 +157,7 @@ public void initializeConfigurationWith(ConfigurationSource configurationSource)
      * @param <T> Configuration tree type.
      * @return Public configuration tree.
      */
+    @Override
     public <V, C extends V, T extends ConfigurationTree<? super V, ? super C>> T getConfiguration(RootKey<T, V, C> rootKey) {
         return (T) configs.get(rootKey.key());
     }
@@ -175,6 +177,7 @@ public SuperRoot superRoot() {
      * @param changesSrc Configuration source to create patch from it.
      * @return Future that is completed on change completion.
      */
+    @Override
     public CompletableFuture<Void> change(ConfigurationSource changesSrc) {
         return changer.change(changesSrc);
     }
@@ -185,6 +188,7 @@ public CompletableFuture<Void> change(ConfigurationSource changesSrc) {
      * @param change Closure that would consume a mutable super root instance.
      * @return Future that is completed on change completion.
      */
+    @Override
     public CompletableFuture<Void> change(Consumer<SuperRootChange> change) {
         return change(new ConfigurationSource() {
             @Override
@@ -252,6 +256,7 @@ private CompletableFuture<Void> combineFutures(Collection<CompletableFuture<?>>
     }
 
     /** Determines if key should be ignored. */
+    @Override
     public KeyIgnorer keyIgnorer() {
         return keyIgnorer;
     }
@@ -262,6 +267,7 @@ public KeyIgnorer keyIgnorer() {
      * <p>Monotonically increasing value that should be incremented each time an attempt is made to notify all listeners of the
      * configuration. Allows to guarantee that new listeners will be called only on the next notification of all configuration listeners.
      */
+    @Override
     public long notificationCount() {
         return changer.notificationCount();
     }
@@ -275,13 +281,13 @@ public long notificationCount() {
      * @param configurationValidator the validator ensuring the correctness of configuration updates.
      * @return a new {@code ConfigurationRegistry} instance initialized with the specified parameters.
      */
-    public static ConfigurationRegistry create(
+    public static ConfigurationRegistryImpl create(
             ConfigurationModule configurationModule,
             ConfigurationStorage storage,
             ConfigurationTreeGenerator generator,
             ConfigurationValidator configurationValidator
     ) {
-        return new ConfigurationRegistry(
+        return new ConfigurationRegistryImpl(
                 configurationModule.rootKeys(),
                 storage,
                 generator,
diff --git a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/CompoundModuleTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/CompoundModuleTest.java
similarity index 100%
rename from modules/runner/src/test/java/org/apache/ignite/internal/configuration/CompoundModuleTest.java
rename to modules/configuration/src/test/java/org/apache/ignite/internal/configuration/CompoundModuleTest.java
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/ConfigurationRegistryTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/ConfigurationRegistryTest.java
index 785946b9def6..634e3785eecb 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/ConfigurationRegistryTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/ConfigurationRegistryTest.java
@@ -57,7 +57,7 @@ public class ConfigurationRegistryTest {
     void testValidationInternalConfigurationExtensions() {
         assertThrows(
                 IllegalArgumentException.class,
-                () -> new ConfigurationRegistry(
+                () -> new ConfigurationRegistryImpl(
                         List.of(SecondRootConfiguration.KEY),
                         new TestConfigurationStorage(LOCAL),
                         new ConfigurationTreeGenerator(
@@ -70,7 +70,7 @@ void testValidationInternalConfigurationExtensions() {
         );
 
         // Check that everything is fine.
-        ConfigurationRegistry configRegistry = new ConfigurationRegistry(
+        ConfigurationRegistry configRegistry = new ConfigurationRegistryImpl(
                 List.of(FirstRootConfiguration.KEY, SecondRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(
@@ -89,7 +89,7 @@ void testValidationPolymorphicConfigurationExtensions() {
         // There is a polymorphic extension that is missing from the schema.
         assertThrows(
                 IllegalArgumentException.class,
-                () -> new ConfigurationRegistry(
+                () -> new ConfigurationRegistryImpl(
                         List.of(ThirdRootConfiguration.KEY),
                         new TestConfigurationStorage(LOCAL),
                         new ConfigurationTreeGenerator(
@@ -104,7 +104,7 @@ void testValidationPolymorphicConfigurationExtensions() {
         // There are two polymorphic extensions with the same id.
         assertThrows(
                 IllegalArgumentException.class,
-                () -> new ConfigurationRegistry(
+                () -> new ConfigurationRegistryImpl(
                         List.of(ThirdRootConfiguration.KEY),
                         new TestConfigurationStorage(LOCAL),
                         new ConfigurationTreeGenerator(
@@ -117,7 +117,7 @@ void testValidationPolymorphicConfigurationExtensions() {
         );
 
         // Check that everything is fine.
-        ConfigurationRegistry configRegistry = new ConfigurationRegistry(
+        ConfigurationRegistry configRegistry = new ConfigurationRegistryImpl(
                 List.of(ThirdRootConfiguration.KEY, FourthRootConfiguration.KEY, FifthRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(
@@ -141,7 +141,7 @@ void testValidationPolymorphicConfigurationExtensions() {
     void missingPolymorphicExtension() {
         IllegalArgumentException ex = assertThrows(
                 IllegalArgumentException.class,
-                () -> new ConfigurationRegistry(
+                () -> new ConfigurationRegistryImpl(
                         List.of(ThirdRootConfiguration.KEY),
                         new TestConfigurationStorage(LOCAL),
                         new ConfigurationTreeGenerator(ThirdRootConfiguration.KEY),
@@ -164,7 +164,7 @@ void testComplicatedPolymorphicConfig() throws Exception {
                 "sixth.poly.intVal", 1
         );
 
-        ConfigurationRegistry registry = new ConfigurationRegistry(
+        ConfigurationRegistry registry = new ConfigurationRegistryImpl(
                 List.of(SixthRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL, bootstrapConfig),
                 new ConfigurationTreeGenerator(
@@ -194,7 +194,7 @@ void testComplicatedPolymorphicConfig() throws Exception {
 
     @Test
     void testPolymorphicGet() {
-        ConfigurationRegistry registry = new ConfigurationRegistry(
+        ConfigurationRegistry registry = new ConfigurationRegistryImpl(
                 List.of(SixthRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(
@@ -228,7 +228,7 @@ void testPolymorphicGet() {
     void testChangeSuperRoot() {
         TestConfigurationStorage storage = new TestConfigurationStorage(LOCAL);
 
-        var registry = new ConfigurationRegistry(
+        var registry = new ConfigurationRegistryImpl(
                 List.of(FirstRootConfiguration.KEY, SecondRootConfiguration.KEY),
                 storage,
                 new ConfigurationTreeGenerator(FirstRootConfiguration.KEY, SecondRootConfiguration.KEY),
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/InjectedValueConfigurationTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/InjectedValueConfigurationTest.java
index 576b36acc000..61f3d83c6abc 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/InjectedValueConfigurationTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/InjectedValueConfigurationTest.java
@@ -76,7 +76,7 @@ void setUp() {
                 HoconInjectedValueRootConfiguration.KEY
         );
 
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 roots,
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(roots, List.of(), List.of()),
@@ -187,7 +187,7 @@ private void change(String hocon) {
     private String asHoconStr(List<String> basePath, String... path) {
         List<String> fullPath = Stream.concat(basePath.stream(), Arrays.stream(path)).collect(Collectors.toList());
 
-        ConfigValue hoconCfg = HoconConverter.represent(registry.superRoot(), fullPath);
+        ConfigValue hoconCfg = HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), fullPath);
 
         return hoconCfg.render(ConfigRenderOptions.concise().setJson(false));
     }
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/RenamedConfigurationTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/RenamedConfigurationTest.java
index 7de112bd150b..3c427dda1399 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/RenamedConfigurationTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/RenamedConfigurationTest.java
@@ -304,7 +304,7 @@ private static void updateConfig(ConfigurationRegistry registry, String updatedC
     }
 
     private ConfigurationRegistry startRegistry(RootKey<?, ?, ?> rootKey, ConfigurationTreeGenerator generator) {
-        var registry = new ConfigurationRegistry(Set.of(rootKey), storage, generator, new TestConfigurationValidator());
+        var registry = new ConfigurationRegistryImpl(Set.of(rootKey), storage, generator, new TestConfigurationValidator());
 
         assertThat(registry.startAsync(new ComponentContext()), willCompleteSuccessfully());
         assertThat(registry.onDefaultsPersisted(), willCompleteSuccessfully());
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/direct/DirectPropertiesTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/direct/DirectPropertiesTest.java
index c3f64e8e1e38..1089c5d5e7e9 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/direct/DirectPropertiesTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/direct/DirectPropertiesTest.java
@@ -44,6 +44,7 @@
 import org.apache.ignite.configuration.annotation.NamedConfigValue;
 import org.apache.ignite.configuration.annotation.Value;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.TestConfigurationValidator;
@@ -106,7 +107,7 @@ public static class DirectNested2ConfigurationSchema {
 
     @BeforeEach
     void setUp() {
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(DirectConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(DirectConfiguration.KEY),
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java
index 7220b5095193..47801f37812a 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java
@@ -50,6 +50,7 @@
 import org.apache.ignite.configuration.annotation.PublicName;
 import org.apache.ignite.configuration.annotation.Value;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.TestConfigurationValidator;
@@ -221,7 +222,7 @@ public static class HoconInjectedNameConfigurationSchema {
      */
     @BeforeAll
     public static void beforeAll() {
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(HoconRootConfiguration.KEY, HoconInjectedNameRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(
@@ -283,12 +284,12 @@ public void toHoconBasic() {
         assertEquals("[]", asHoconStr(List.of("root", "arraysList")));
 
         assertThrowsIllegalArgException(
-                () -> HoconConverter.represent(registry.superRoot(), List.of("doot")),
+                () -> HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), List.of("doot")),
                 "Configuration value 'doot' has not been found"
         );
 
         assertThrowsIllegalArgException(
-                () -> HoconConverter.represent(registry.superRoot(), List.of("root", "x")),
+                () -> HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), List.of("root", "x")),
                 "Configuration value 'root.x' has not been found"
         );
 
@@ -369,7 +370,7 @@ public void testHoconArraysSerialization() throws Exception {
     private static String asHoconStr(List<String> basePath, String... path) {
         List<String> fullPath = Stream.concat(basePath.stream(), Arrays.stream(path)).collect(Collectors.toList());
 
-        ConfigValue hoconCfg = HoconConverter.represent(registry.superRoot(), fullPath);
+        ConfigValue hoconCfg = HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), fullPath);
 
         return hoconCfg.render(ConfigRenderOptions.concise().setJson(false));
     }
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationAnyListenerTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationAnyListenerTest.java
index ce4aaf811c56..ff822595779a 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationAnyListenerTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationAnyListenerTest.java
@@ -55,6 +55,7 @@
 import org.apache.ignite.configuration.notifications.ConfigurationNamedListListener;
 import org.apache.ignite.configuration.notifications.ConfigurationNotificationEvent;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.TestConfigurationValidator;
@@ -164,7 +165,7 @@ public void before() throws Exception {
                 List.of(),
                 List.of(FirstPolyAnyConfigurationSchema.class, SecondPolyAnyConfigurationSchema.class)
         );
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(RootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationListenerTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationListenerTest.java
index ac4d49704fff..b5cbb59a6df8 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationListenerTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationListenerTest.java
@@ -68,6 +68,7 @@
 import org.apache.ignite.configuration.notifications.ConfigurationNamedListListener;
 import org.apache.ignite.configuration.notifications.ConfigurationNotificationEvent;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.DynamicConfiguration;
 import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
@@ -184,7 +185,7 @@ public void before() {
                 List.of(InternalChildConfigurationSchema.class),
                 List.of(StringPolyConfigurationSchema.class, LongPolyConfigurationSchema.class)
         );
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(ParentConfiguration.KEY),
                 storage,
                 generator,
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/sample/UsageTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/sample/UsageTest.java
index c38c08860869..68443a735e44 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/sample/UsageTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/sample/UsageTest.java
@@ -28,6 +28,7 @@
 
 import java.util.List;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.TestConfigurationValidator;
@@ -51,7 +52,7 @@ public void after() {
      */
     @Test
     public void test() throws Exception {
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(LocalConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(LocalConfiguration.KEY),
@@ -110,7 +111,7 @@ public void multiRootConfiguration() throws Exception {
 
         long testLongValue = 30_000L;
 
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(NetworkConfiguration.KEY, LocalConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(NetworkConfiguration.KEY, LocalConfiguration.KEY),
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/InternalIdTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/InternalIdTest.java
index c038264ce5e2..ce2cac6cc8eb 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/InternalIdTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/InternalIdTest.java
@@ -35,6 +35,7 @@
 import org.apache.ignite.configuration.annotation.PolymorphicConfigInstance;
 import org.apache.ignite.configuration.annotation.PolymorphicId;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.direct.DirectPropertiesTest;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
@@ -90,7 +91,7 @@ void setUp() {
                 List.of(InternalIdFooConfigurationSchema.class)
         );
 
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(InternalIdParentConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/core/build.gradle b/modules/core/build.gradle
index 19e1e2cc0a9f..8117f8df0aca 100644
--- a/modules/core/build.gradle
+++ b/modules/core/build.gradle
@@ -23,12 +23,15 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 description = 'ignite-core'
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     compileOnly libs.spotbugs.annotations
 
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.caffeine
     implementation project(':ignite-api')
+    implementation libs.micronaut.inject
 
     testAnnotationProcessor libs.auto.service
     testAnnotationProcessor libs.jmh.annotation.processor
@@ -46,6 +49,7 @@ dependencies {
     testFixturesImplementation libs.auto.service.annotations
     testFixturesImplementation libs.junit.testkit
     testFixturesImplementation libs.awaitility
+    testFixturesImplementation libs.micronaut.inject
 }
 
 test {
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/components/IgniteStartupPhase.java b/modules/core/src/main/java/org/apache/ignite/internal/components/IgniteStartupPhase.java
new file mode 100644
index 000000000000..a951bd2a04a0
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/IgniteStartupPhase.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.components;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks an {@link org.apache.ignite.internal.manager.IgniteComponent} bean with the startup phase
+ * in which it should be started.
+ *
+ * <p>Components without this annotation default to {@link StartupPhase#PHASE_1}.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface IgniteStartupPhase {
+    /** The startup phase for this component. */
+    StartupPhase value();
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/components/LongJvmPauseDetector.java b/modules/core/src/main/java/org/apache/ignite/internal/components/LongJvmPauseDetector.java
index 5cd306d64ce5..a722be404aa8 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/components/LongJvmPauseDetector.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/LongJvmPauseDetector.java
@@ -21,6 +21,9 @@
 import static org.apache.ignite.internal.lang.IgniteSystemProperties.getInteger;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.concurrent.CompletableFuture;
@@ -42,6 +45,9 @@
  * properties IGNITE_JVM_PAUSE_DETECTOR_PRECISION, IGNITE_JVM_PAUSE_DETECTOR_THRESHOLD and IGNITE_JVM_PAUSE_DETECTOR_LAST_EVENTS_COUNT
  * accordingly.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(100)
 public class LongJvmPauseDetector implements IgniteComponent {
     private final IgniteLogger log = Loggers.forClass(LongJvmPauseDetector.class);
 
@@ -91,6 +97,12 @@ public LongJvmPauseDetector(String nodeName) {
         this.nodeName = nodeName;
     }
 
+    /** Constructor for DI injection. */
+    @Inject
+    public LongJvmPauseDetector(NodeIdentity nodeIdentity) {
+        this(nodeIdentity.nodeName());
+    }
+
     /** {@inheritDoc} */
     @Override
     public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java b/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
new file mode 100644
index 000000000000..d68d727de680
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.components;
+
+import java.nio.file.Path;
+import java.util.UUID;
+import java.util.function.Supplier;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Holds basic node identity and environment parameters that components across all modules commonly need.
+ *
+ * <p>This POJO is created early during node startup and registered as a singleton bean in the DI context,
+ * so any module that depends on {@code ignite-core} can inject it without creating a dependency on the runner module.
+ */
+public class NodeIdentity {
+    private final String nodeName;
+
+    private final Path workDir;
+
+    private final Path configPath;
+
+    @Nullable
+    private final ClassLoader serviceProviderClassLoader;
+
+    private final Supplier<UUID> clusterIdSupplier;
+
+    /** Constructor. */
+    public NodeIdentity(
+            String nodeName,
+            Path workDir,
+            Path configPath,
+            @Nullable ClassLoader serviceProviderClassLoader,
+            Supplier<UUID> clusterIdSupplier
+    ) {
+        this.nodeName = nodeName;
+        this.workDir = workDir;
+        this.configPath = configPath;
+        this.serviceProviderClassLoader = serviceProviderClassLoader;
+        this.clusterIdSupplier = clusterIdSupplier;
+    }
+
+    /** Node name. */
+    public String nodeName() {
+        return nodeName;
+    }
+
+    /** Node working directory. */
+    public Path workDir() {
+        return workDir;
+    }
+
+    /** Path to the node configuration file. */
+    public Path configPath() {
+        return configPath;
+    }
+
+    /** Class loader used to discover service providers, or {@code null} for the system class loader. */
+    @Nullable
+    public ClassLoader serviceProviderClassLoader() {
+        return serviceProviderClassLoader;
+    }
+
+    /** Supplier of the cluster ID; resolved lazily after cluster initialization. */
+    public Supplier<UUID> clusterIdSupplier() {
+        return clusterIdSupplier;
+    }
+}
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/components/StartupPhase.java b/modules/core/src/main/java/org/apache/ignite/internal/components/StartupPhase.java
new file mode 100644
index 000000000000..ea1046ab6265
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/StartupPhase.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.components;
+
+/**
+ * Defines the startup phase in which an {@link org.apache.ignite.internal.manager.IgniteComponent} should be started.
+ *
+ * <p>Ignite node startup happens in two phases:
+ * <ul>
+ *     <li>{@link #PHASE_1} — before the node joins the cluster (pre-join).</li>
+ *     <li>{@link #PHASE_2} — after the node joins the cluster (post-join).</li>
+ * </ul>
+ */
+public enum StartupPhase {
+    /** Components started before the node joins the cluster. */
+    PHASE_1,
+
+    /** Components started after the node joins the cluster. */
+    PHASE_2
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/ComponentWorkingDir.java b/modules/core/src/main/java/org/apache/ignite/internal/configuration/ComponentWorkingDir.java
similarity index 100%
rename from modules/runner/src/main/java/org/apache/ignite/internal/configuration/ComponentWorkingDir.java
rename to modules/core/src/main/java/org/apache/ignite/internal/configuration/ComponentWorkingDir.java
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/hlc/ClockWaiter.java b/modules/core/src/main/java/org/apache/ignite/internal/hlc/ClockWaiter.java
index cef1c7d7b503..af73bac73b22 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/hlc/ClockWaiter.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/hlc/ClockWaiter.java
@@ -21,6 +21,10 @@
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;
@@ -29,6 +33,9 @@
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -41,6 +48,9 @@
  * Allows to wait for the supplied clock to reach a required timestamp. It only uses the clock itself,
  * no SafeTime mechanisms are involved.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(500)
 public class ClockWaiter implements IgniteComponent {
     private final HybridClock clock;
 
@@ -60,6 +70,12 @@ public class ClockWaiter implements IgniteComponent {
     /** Executor that executes completion of futures returned to the user, so it might take arbitrarily heavy operations. */
     private final ExecutorService futureExecutor;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public ClockWaiter(NodeIdentity identity, HybridClock clock, @Named("commonScheduler") ScheduledExecutorService scheduler) {
+        this(identity.nodeName(), clock, scheduler);
+    }
+
     /**
      * Creates a new {@link ClockWaiter}.
      *
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/hlc/HybridClockImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/hlc/HybridClockImpl.java
index d2f434c0e1f6..c460374ead64 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/hlc/HybridClockImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/hlc/HybridClockImpl.java
@@ -21,6 +21,8 @@
 import static org.apache.ignite.internal.hlc.HybridTimestamp.LOGICAL_TIME_BITS_SIZE;
 import static org.apache.ignite.internal.hlc.HybridTimestamp.hybridTimestamp;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
@@ -36,6 +38,7 @@
 /**
  * A Hybrid Logical Clock implementation.
  */
+@Singleton
 public class HybridClockImpl implements HybridClock {
     private final IgniteLogger log = Loggers.forClass(HybridClockImpl.class);
 
@@ -56,6 +59,7 @@ public HybridClockImpl() {
         this.failureProcessor = null;
     }
 
+    @Inject
     public HybridClockImpl(FailureProcessor failureProcessor) {
         this.failureProcessor = failureProcessor;
     }
diff --git a/modules/di/build.gradle b/modules/di/build.gradle
new file mode 100644
index 000000000000..9e74b98d2b4c
--- /dev/null
+++ b/modules/di/build.gradle
@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply from: "$rootDir/buildscripts/java-core.gradle"
+apply from: "$rootDir/buildscripts/publishing.gradle"
+apply from: "$rootDir/buildscripts/java-junit5.gradle"
+
+dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
+    implementation project(':ignite-core')
+    implementation libs.micronaut.inject
+    implementation libs.jetbrains.annotations
+
+    testAnnotationProcessor libs.micronaut.inject.annotation.processor
+    testImplementation libs.micronaut.inject
+    testImplementation testFixtures(project(':ignite-core'))
+}
+
+description = 'ignite-di'
\ No newline at end of file
diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
new file mode 100644
index 000000000000..a8e794a70ab8
--- /dev/null
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
@@ -0,0 +1,190 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import static java.util.Collections.reverse;
+import static java.util.concurrent.CompletableFuture.allOf;
+
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.BeanRegistration;
+import io.micronaut.inject.BeanDefinition;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.manager.ComponentContext;
+import org.apache.ignite.internal.manager.IgniteComponent;
+import org.apache.ignite.internal.util.IgniteUtils;
+
+/**
+ * Manages the lifecycle of {@link IgniteComponent} beans obtained from a Micronaut {@link ApplicationContext}.
+ *
+ * <p>Components are grouped by {@link StartupPhase} and can be started per-phase.
+ * Stopping is done in reverse order of startup across all phases.
+ */
+public class IgniteComponentLifecycleManager {
+    private final Map<StartupPhase, List<IgniteComponent>> componentsByPhase;
+
+    private final List<IgniteComponent> startedComponents = new CopyOnWriteArrayList<>();
+
+    /**
+     * Creates the lifecycle manager by collecting all {@link IgniteComponent} beans from the given context
+     * and grouping them by their {@link IgniteStartupPhase} annotation.
+     *
+     * @param context Micronaut application context containing the component beans.
+     */
+    public IgniteComponentLifecycleManager(ApplicationContext context) {
+        componentsByPhase = new EnumMap<>(StartupPhase.class);
+
+        for (StartupPhase phase : StartupPhase.values()) {
+            componentsByPhase.put(phase, new ArrayList<>());
+        }
+
+        Collection<IgniteComponent> allComponents = context.getBeansOfType(IgniteComponent.class);
+
+        for (IgniteComponent component : allComponents) {
+            StartupPhase phase = resolvePhase(context, component);
+            componentsByPhase.get(phase).add(component);
+        }
+    }
+
+    /**
+     * Excludes specific component instances from being started by {@link #startPhase}.
+     * Excluded components are also removed from the stop list unless explicitly added via {@link #markAsStarted}.
+     *
+     * <p>Use this for components that are started manually due to special ordering requirements
+     * (e.g., nodeConfigRegistry must start before other beans are created).
+     *
+     * @param components Components to exclude (identity-based comparison).
+     */
+    public void exclude(IgniteComponent... components) {
+        Set<IgniteComponent> excludeSet = newIdentitySet(components);
+
+        for (List<IgniteComponent> phaseList : componentsByPhase.values()) {
+            phaseList.removeIf(excludeSet::contains);
+        }
+    }
+
+    /**
+     * Marks components as started externally, so they will be stopped during {@link #stopAll}.
+     *
+     * <p>Use this for components that are excluded from {@link #startPhase} but still need lifecycle management.
+     *
+     * @param components Components that were started externally.
+     */
+    public void markAsStarted(IgniteComponent... components) {
+        Collections.addAll(startedComponents, components);
+    }
+
+    private static Set<IgniteComponent> newIdentitySet(IgniteComponent... components) {
+        Set<IgniteComponent> set = Collections.newSetFromMap(new IdentityHashMap<>());
+        Collections.addAll(set, components);
+        return set;
+    }
+
+    /**
+     * Starts all components belonging to the given phase.
+     *
+     * @param phase The startup phase.
+     * @param componentContext The component lifecycle context.
+     * @return Future that completes when all components in the phase have started.
+     */
+    public CompletableFuture<Void> startPhase(StartupPhase phase, ComponentContext componentContext) {
+        List<IgniteComponent> components = componentsByPhase.get(phase);
+
+        CompletableFuture<?>[] futures = new CompletableFuture[components.size()];
+
+        for (int i = 0; i < components.size(); i++) {
+            IgniteComponent component = components.get(i);
+            startedComponents.add(component);
+            futures[i] = component.startAsync(componentContext);
+        }
+
+        return allOf(futures);
+    }
+
+    /**
+     * Stops all started components in reverse order of startup.
+     * Calls {@link IgniteComponent#beforeNodeStop()} on each component first,
+     * then {@link IgniteComponent#stopAsync(ComponentContext)}.
+     *
+     * @param componentContext The component lifecycle context.
+     * @return Future that completes when all components have stopped.
+     */
+    public CompletableFuture<Void> stopAll(ComponentContext componentContext) {
+        List<IgniteComponent> components = new ArrayList<>(startedComponents);
+        reverse(components);
+
+        return IgniteUtils.stopAsync(componentContext, components);
+    }
+
+    /**
+     * Returns the components assigned to the given phase (unmodifiable view for testing).
+     *
+     * @param phase The startup phase.
+     * @return List of components in that phase.
+     */
+    public List<IgniteComponent> componentsForPhase(StartupPhase phase) {
+        return List.copyOf(componentsByPhase.get(phase));
+    }
+
+    /**
+     * Returns all started components in startup order.
+     *
+     * @return List of started components.
+     */
+    public List<IgniteComponent> startedComponents() {
+        return List.copyOf(startedComponents);
+    }
+
+    private static StartupPhase resolvePhase(ApplicationContext context, IgniteComponent component) {
+        // First, try to get the phase from the BeanRegistration for this specific instance.
+        // Using findBeanRegistration(instance) instead of findBeanDefinition(class) avoids
+        // NonUniqueBeanException when multiple beans of the same type exist (e.g., two ConfigurationRegistry
+        // beans with different @Named qualifiers).
+        Optional<? extends BeanRegistration<? extends IgniteComponent>> registration =
+                context.findBeanRegistration(component);
+
+        if (registration.isPresent()) {
+            BeanDefinition<? extends IgniteComponent> definition = registration.get().getBeanDefinition();
+            Optional<StartupPhase> phase = definition
+                    .findAnnotation(IgniteStartupPhase.class)
+                    .flatMap(av -> av.enumValue(StartupPhase.class));
+            if (phase.isPresent()) {
+                return phase.get();
+            }
+        }
+
+        // Fall back to class-level annotation.
+        IgniteStartupPhase classAnnotation = component.getClass().getAnnotation(IgniteStartupPhase.class);
+        if (classAnnotation != null) {
+            return classAnnotation.value();
+        }
+
+        return StartupPhase.PHASE_1;
+    }
+}
diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
new file mode 100644
index 000000000000..c430704c4406
--- /dev/null
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.ApplicationContextBuilder;
+import io.micronaut.context.ApplicationContextConfiguration;
+import io.micronaut.context.DefaultApplicationContext;
+import io.micronaut.inject.BeanDefinitionReference;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Builds and manages a non-HTTP Micronaut {@link ApplicationContext} for core Ignite component wiring.
+ *
+ * <p>This context is separate from the REST module's HTTP-enabled Micronaut context.
+ * It handles construction and dependency injection of {@link org.apache.ignite.internal.manager.IgniteComponent}
+ * beans, while lifecycle management (start/stop) remains with {@link IgniteComponentLifecycleManager}.
+ *
+ * <p>Usage:
+ * <pre>{@code
+ * ApplicationContext ctx = IgniteDiContext.builder()
+ *         .withSingleton(seedParams)
+ *         .withPackages("org.apache.ignite.internal.app")
+ *         .build();
+ * }</pre>
+ */
+public final class IgniteDiContext {
+    /**
+     * Creates a new builder for the core DI context.
+     *
+     * @return A new builder instance.
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /** Builder for constructing the core DI {@link ApplicationContext}. */
+    public static class Builder {
+        private final List<Object> singletons = new ArrayList<>();
+
+        private final List<String> packages = new ArrayList<>();
+
+        private final List<String> excludedPackages = new ArrayList<>();
+
+        private final List<String> includedPackages = new ArrayList<>();
+
+        /**
+         * Registers a seed singleton that will be available for injection in the context.
+         *
+         * @param singleton The object to register as a singleton bean.
+         * @return This builder for chaining.
+         */
+        public Builder withSingleton(Object singleton) {
+            singletons.add(singleton);
+            return this;
+        }
+
+        /**
+         * Adds packages to scan for bean definitions.
+         *
+         * @param packageNames Package names to scan.
+         * @return This builder for chaining.
+         */
+        public Builder withPackages(String... packageNames) {
+            Collections.addAll(packages, packageNames);
+            return this;
+        }
+
+        /**
+         * Excludes bean definitions from the specified packages. Bean definitions whose generated class name
+         * starts with any of the given package prefixes will not be loaded into the context.
+         *
+         * <p>This is needed to prevent compile-time discovered beans from other Micronaut contexts
+         * (e.g., REST module factories) from being loaded into this core DI context.
+         *
+         * @param packagePrefixes Package prefixes to exclude (e.g., {@code "org.apache.ignite.internal.rest"}).
+         * @return This builder for chaining.
+         */
+        public Builder withExcludedPackages(String... packagePrefixes) {
+            Collections.addAll(excludedPackages, packagePrefixes);
+            return this;
+        }
+
+        /**
+         * Restricts bean discovery to only the specified packages. Bean definitions whose generated class name
+         * does not start with any of the given package prefixes will not be loaded into the context.
+         *
+         * @param packagePrefixes Package prefixes to include (e.g., {@code "org.apache.ignite.internal.di"}).
+         * @return This builder for chaining.
+         */
+        public Builder withIncludedPackages(String... packagePrefixes) {
+            Collections.addAll(includedPackages, packagePrefixes);
+            return this;
+        }
+
+        /**
+         * Builds and starts the Micronaut {@link ApplicationContext}.
+         *
+         * @return The started application context.
+         */
+        public ApplicationContext build() {
+            ApplicationContextBuilder contextBuilder = ApplicationContext.builder()
+                    .deduceEnvironment(false)
+                    .banner(false);
+
+            if (!packages.isEmpty()) {
+                contextBuilder.packages(packages.toArray(String[]::new));
+            }
+
+            if (!singletons.isEmpty()) {
+                contextBuilder.singletons(singletons.toArray());
+            }
+
+            if (excludedPackages.isEmpty() && includedPackages.isEmpty()) {
+                return contextBuilder.start();
+            }
+
+            // Build the context manually so we can override bean discovery to filter
+            // unwanted packages (e.g., REST module beans that conflict with core DI beans).
+            // We replicate the singleton registration that ApplicationContextBuilder.build() does,
+            // because DefaultApplicationContext(configuration) doesn't auto-register them.
+            List<String> excluded = List.copyOf(excludedPackages);
+            List<String> included = List.copyOf(includedPackages);
+
+            @SuppressWarnings("rawtypes")
+            ApplicationContext context = new DefaultApplicationContext((ApplicationContextConfiguration) contextBuilder) {
+                @Override
+                protected List<BeanDefinitionReference> resolveBeanDefinitionReferences() {
+                    List<BeanDefinitionReference> refs = super.resolveBeanDefinitionReferences();
+
+                    refs.removeIf(ref -> {
+                        String name = ref.getBeanDefinitionName();
+
+                        for (String pkg : excluded) {
+                            if (name.startsWith(pkg + ".")) {
+                                return true;
+                            }
+                        }
+
+                        if (!included.isEmpty() && name.startsWith("org.apache.ignite.")) {
+                            for (String pkg : included) {
+                                if (name.startsWith(pkg + ".")) {
+                                    return false;
+                                }
+                            }
+                            return true;
+                        }
+
+                        return false;
+                    });
+
+                    return refs;
+                }
+            };
+
+            for (Object singleton : singletons) {
+                context.registerSingleton(singleton);
+            }
+
+            context.start();
+
+            return context;
+        }
+    }
+}
diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
new file mode 100644
index 000000000000..ce568a0413e0
--- /dev/null
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
@@ -0,0 +1,220 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import static org.apache.ignite.internal.testframework.matchers.CompletableFutureMatcher.willCompleteSuccessfully;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.empty;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.micronaut.context.ApplicationContext;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.manager.ComponentContext;
+import org.apache.ignite.internal.manager.IgniteComponent;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests for {@link IgniteComponentLifecycleManager}.
+ */
+public class IgniteComponentLifecycleManagerTest {
+    private static final List<String> EVENTS = Collections.synchronizedList(new ArrayList<>());
+
+    private ApplicationContext appContext;
+
+    @AfterEach
+    void tearDown() {
+        EVENTS.clear();
+
+        if (appContext != null && appContext.isRunning()) {
+            appContext.close();
+        }
+    }
+
+    @Test
+    void componentsGroupedByPhase() {
+        appContext = IgniteDiContext.builder()
+                .withIncludedPackages("org.apache.ignite.internal.di")
+                .build();
+
+        IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
+
+        // TestComponentFactory produces one PHASE_1 and one PHASE_2 bean.
+        assertThat(manager.componentsForPhase(StartupPhase.PHASE_1), hasSize(1));
+        assertThat(manager.componentsForPhase(StartupPhase.PHASE_2), hasSize(1));
+    }
+
+    @Test
+    void startPhaseStartsComponentsAndTracksOrder() {
+        appContext = IgniteDiContext.builder()
+                .withIncludedPackages("org.apache.ignite.internal.di")
+                .build();
+
+        IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
+
+        assertThat(manager.startedComponents(), is(empty()));
+
+        assertThat(
+                manager.startPhase(StartupPhase.PHASE_1, new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+
+        List<IgniteComponent> started = manager.startedComponents();
+        assertThat(started, hasSize(manager.componentsForPhase(StartupPhase.PHASE_1).size()));
+    }
+
+    @Test
+    void stopAllStopsInReverseStartOrder() {
+        TrackingComponentA compA = new TrackingComponentA();
+        TrackingComponentB compB = new TrackingComponentB();
+
+        appContext = IgniteDiContext.builder()
+                .withSingleton(compA)
+                .withSingleton(compB)
+                .withIncludedPackages("org.apache.ignite.internal.di")
+                .build();
+
+        IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
+
+        // Start all phases so all components (factory + tracking) are started.
+        assertThat(
+                manager.startPhase(StartupPhase.PHASE_1, new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+
+        // Record start order of tracking components.
+        List<String> startOrder = EVENTS.stream()
+                .filter(e -> e.startsWith("start:"))
+                .map(e -> e.substring("start:".length()))
+                .collect(Collectors.toList());
+        assertEquals(2, startOrder.size(), "Expected exactly 2 tracking component start events");
+
+        EVENTS.clear();
+
+        assertThat(
+                manager.stopAll(new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+
+        // Verify beforeNodeStop is called in reverse of start order.
+        List<String> beforeStopOrder = EVENTS.stream()
+                .filter(e -> e.startsWith("beforeNodeStop:"))
+                .map(e -> e.substring("beforeNodeStop:".length()))
+                .collect(Collectors.toList());
+
+        List<String> stopOrder = EVENTS.stream()
+                .filter(e -> e.startsWith("stop:"))
+                .map(e -> e.substring("stop:".length()))
+                .collect(Collectors.toList());
+
+        List<String> expectedReverse = new ArrayList<>(startOrder);
+        Collections.reverse(expectedReverse);
+
+        assertEquals(expectedReverse, beforeStopOrder, "beforeNodeStop should be in reverse start order");
+        assertEquals(expectedReverse, stopOrder, "stopAsync should be in reverse start order");
+
+        // Verify all beforeNodeStop calls happen before any stopAsync calls.
+        int lastBeforeStop = -1;
+        int firstStop = Integer.MAX_VALUE;
+        for (int i = 0; i < EVENTS.size(); i++) {
+            if (EVENTS.get(i).startsWith("beforeNodeStop:")) {
+                lastBeforeStop = i;
+            }
+            if (EVENTS.get(i).startsWith("stop:") && i < firstStop) {
+                firstStop = i;
+            }
+        }
+        assertTrue(lastBeforeStop < firstStop, "All beforeNodeStop calls should precede stopAsync calls");
+    }
+
+    @Test
+    void multiPhaseStartAndStop() {
+        appContext = IgniteDiContext.builder()
+                .withIncludedPackages("org.apache.ignite.internal.di")
+                .build();
+
+        IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
+
+        assertThat(
+                manager.startPhase(StartupPhase.PHASE_1, new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+        int phase1Count = manager.startedComponents().size();
+        assertTrue(phase1Count > 0, "Phase 1 should have components");
+
+        assertThat(
+                manager.startPhase(StartupPhase.PHASE_2, new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+        int totalCount = manager.startedComponents().size();
+        assertTrue(totalCount > phase1Count, "Phase 2 should add more started components");
+
+        assertThat(
+                manager.stopAll(new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+    }
+
+    /** Base test component that records lifecycle events. */
+    private abstract static class TrackingComponent implements IgniteComponent {
+        private final String name;
+
+        TrackingComponent(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
+            EVENTS.add("start:" + name);
+            return CompletableFuture.completedFuture(null);
+        }
+
+        @Override
+        public void beforeNodeStop() {
+            EVENTS.add("beforeNodeStop:" + name);
+        }
+
+        @Override
+        public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
+            EVENTS.add("stop:" + name);
+            return CompletableFuture.completedFuture(null);
+        }
+    }
+
+    /** Distinct type so Micronaut registers it as a separate bean. */
+    private static class TrackingComponentA extends TrackingComponent {
+        TrackingComponentA() {
+            super("A");
+        }
+    }
+
+    /** Distinct type so Micronaut registers it as a separate bean. */
+    private static class TrackingComponentB extends TrackingComponent {
+        TrackingComponentB() {
+            super("B");
+        }
+    }
+}
diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java
new file mode 100644
index 000000000000..12584b2dc34a
--- /dev/null
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java
@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.micronaut.context.ApplicationContext;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests for {@link IgniteDiContext}.
+ */
+public class IgniteDiContextTest {
+    @Test
+    void buildsRunningContext() {
+        try (ApplicationContext ctx = IgniteDiContext.builder().build()) {
+            assertTrue(ctx.isRunning());
+        }
+    }
+
+    @Test
+    void seedSingletonsAreInjectable() {
+        String seedValue = "test-node";
+
+        try (ApplicationContext ctx = IgniteDiContext.builder()
+                .withSingleton(seedValue)
+                .build()) {
+            String retrieved = ctx.getBean(String.class);
+            assertThat(retrieved, is(sameInstance(seedValue)));
+        }
+    }
+
+    @Test
+    void seedSingletonsOfDifferentTypesCoexist() {
+        SeedA seedA = new SeedA("a");
+        SeedB seedB = new SeedB(42);
+
+        try (ApplicationContext ctx = IgniteDiContext.builder()
+                .withSingleton(seedA)
+                .withSingleton(seedB)
+                .build()) {
+            assertThat(ctx.getBean(SeedA.class), is(sameInstance(seedA)));
+            assertThat(ctx.getBean(SeedB.class), is(sameInstance(seedB)));
+        }
+    }
+
+    @Test
+    void twoContextsCoexistIndependently() {
+        SeedA seedForCtx1 = new SeedA("ctx1");
+        SeedA seedForCtx2 = new SeedA("ctx2");
+
+        try (ApplicationContext ctx1 = IgniteDiContext.builder()
+                .withSingleton(seedForCtx1)
+                .build();
+                ApplicationContext ctx2 = IgniteDiContext.builder()
+                        .withSingleton(seedForCtx2)
+                        .build()) {
+            assertThat(ctx1.getBean(SeedA.class).value, is("ctx1"));
+            assertThat(ctx2.getBean(SeedA.class).value, is("ctx2"));
+
+            assertTrue(ctx1.isRunning());
+            assertTrue(ctx2.isRunning());
+        }
+    }
+
+    @Test
+    void contextDiscoversBeanDefinitions() {
+        try (ApplicationContext ctx = IgniteDiContext.builder().build()) {
+            // TestComponentFactory (from test classpath) should be discovered.
+            assertThat(
+                    ctx.getBean(TestComponentFactory.TestPhase1Component.class),
+                    is(notNullValue())
+            );
+        }
+    }
+
+    @Test
+    void closedContextStopsCleanly() {
+        ApplicationContext ctx = IgniteDiContext.builder().build();
+
+        assertTrue(ctx.isRunning());
+        assertDoesNotThrow(ctx::close);
+        assertFalse(ctx.isRunning());
+    }
+
+    /** Simple seed type for testing. */
+    private static class SeedA {
+        final String value;
+
+        SeedA(String value) {
+            this.value = value;
+        }
+    }
+
+    /** Another seed type for testing. */
+    private static class SeedB {
+        final int value;
+
+        SeedB(int value) {
+            this.value = value;
+        }
+    }
+}
diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java b/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java
new file mode 100644
index 000000000000..0b6feb35b97e
--- /dev/null
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java
@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import io.micronaut.context.annotation.Bean;
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Singleton;
+import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.manager.ComponentContext;
+import org.apache.ignite.internal.manager.IgniteComponent;
+
+/**
+ * Test factory that produces {@link IgniteComponent} beans annotated with different {@link IgniteStartupPhase}s.
+ */
+@Factory
+class TestComponentFactory {
+    @Bean
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    TestPhase1Component phase1Component() {
+        return new TestPhase1Component();
+    }
+
+    @Bean
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    TestPhase2Component phase2Component() {
+        return new TestPhase2Component();
+    }
+
+    /** Test component for Phase 1. */
+    static class TestPhase1Component implements IgniteComponent {
+        @Override
+        public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
+            return CompletableFuture.completedFuture(null);
+        }
+
+        @Override
+        public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
+            return CompletableFuture.completedFuture(null);
+        }
+    }
+
+    /** Test component for Phase 2. */
+    static class TestPhase2Component implements IgniteComponent {
+        @Override
+        public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
+            return CompletableFuture.completedFuture(null);
+        }
+
+        @Override
+        public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
+            return CompletableFuture.completedFuture(null);
+        }
+    }
+}
diff --git a/modules/distribution-zones/build.gradle b/modules/distribution-zones/build.gradle
index 253355ea4f42..957dc05120f0 100644
--- a/modules/distribution-zones/build.gradle
+++ b/modules/distribution-zones/build.gradle
@@ -24,6 +24,7 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-core')
     implementation project(':ignite-configuration-api')
@@ -39,7 +40,9 @@ dependencies {
     implementation project(':ignite-raft-api')
     implementation project(':ignite-failure-handler')
     implementation project(':ignite-metrics')
+    implementation project(':ignite-network-api')
 
+    implementation libs.micronaut.inject
     implementation libs.auto.service.annotations
     implementation libs.fastutil.core
     implementation libs.jetbrains.annotations
diff --git a/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/distributionzones/ItIgniteDistributionZoneManagerNodeRestartTest.java b/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/distributionzones/ItIgniteDistributionZoneManagerNodeRestartTest.java
index f10bf739de2e..b16b480c5a80 100644
--- a/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/distributionzones/ItIgniteDistributionZoneManagerNodeRestartTest.java
+++ b/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/distributionzones/ItIgniteDistributionZoneManagerNodeRestartTest.java
@@ -92,7 +92,7 @@
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyServiceImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
-import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfigWriteException;
 import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
@@ -219,7 +219,7 @@ private PartialNode startPartialNode(int idx, Consumer<MetaStorageManager> metaS
                 modules.local().polymorphicSchemaExtensions()
         );
 
-        var nodeConfigRegistry = new ConfigurationRegistry(
+        var nodeConfigRegistry = new ConfigurationRegistryImpl(
                 modules.local().rootKeys(),
                 new LocalFileConfigurationStorage(configFile, localConfigurationGenerator, modules.local()),
                 localConfigurationGenerator,
@@ -298,7 +298,7 @@ private PartialNode startPartialNode(int idx, Consumer<MetaStorageManager> metaS
         Set<Validator<?, ?>> validators = new HashSet<>(modules.distributed().validators());
         validators.remove(AuthenticationProvidersValidatorImpl.INSTANCE);
 
-        var clusterConfigRegistry = new ConfigurationRegistry(
+        var clusterConfigRegistry = new ConfigurationRegistryImpl(
                 modules.distributed().rootKeys(),
                 cfgStorage,
                 distributedConfigurationGenerator,
diff --git a/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java b/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
index c9907b58303c..565729b14889 100644
--- a/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
+++ b/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
@@ -121,6 +121,7 @@
 import org.apache.ignite.internal.configuration.ClusterConfiguration;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
@@ -1247,7 +1248,7 @@ private class Node {
             Path configPath = workDir.resolve(testInfo.getDisplayName());
             TestIgnitionManager.writeConfigurationFileApplyingTestDefaults(configPath);
 
-            nodeConfigRegistry = new ConfigurationRegistry(
+            nodeConfigRegistry = new ConfigurationRegistryImpl(
                     List.of(NodeConfiguration.KEY),
                     new LocalFileConfigurationStorage(configPath, nodeCfgGenerator, null),
                     nodeCfgGenerator,
@@ -1404,7 +1405,7 @@ private class Node {
                     List.of()
             );
 
-            clusterConfigRegistry = new ConfigurationRegistry(
+            clusterConfigRegistry = new ConfigurationRegistryImpl(
                     List.of(ClusterConfiguration.KEY),
                     cfgStorage,
                     clusterCfgGenerator,
diff --git a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java
index 4c92a01031b9..a3f2d1820f68 100644
--- a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java
+++ b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java
@@ -58,6 +58,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -82,6 +85,9 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
 import org.apache.ignite.internal.distributionzones.events.HaZoneTopologyUpdateEvent;
@@ -114,6 +120,7 @@
 import org.apache.ignite.internal.metastorage.dsl.StatementResult;
 import org.apache.ignite.internal.metastorage.dsl.Update;
 import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.util.IgniteSpinBusyLock;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
@@ -121,6 +128,9 @@
 /**
  * Distribution zones manager.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1100)
 public class DistributionZoneManager extends
         AbstractEventProducer<HaZoneTopologyUpdateEvent, HaZoneTopologyUpdateEventParams> implements IgniteComponent {
     /** The logger. */
@@ -192,6 +202,36 @@ public class DistributionZoneManager extends
     @Nullable
     private Predicate<NodeWithAttributes> additionalNodeFilter = null;
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public DistributionZoneManager(
+            NodeIdentity nodeIdentity,
+            TopologyService topologyService,
+            MetaStorageManager metaStorageManager,
+            LogicalTopologyService logicalTopologyService,
+            FailureProcessor failureProcessor,
+            CatalogManager catalogManager,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            ClockService clockService,
+            MetricManager metricManager,
+            LowWatermark lowWatermark
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                () -> topologyService.localMember().id(),
+                metaStorageManager,
+                logicalTopologyService,
+                failureProcessor,
+                catalogManager,
+                systemDistributedConfiguration,
+                clockService,
+                metricManager,
+                lowWatermark
+        );
+    }
+
     /**
      * Constructor.
      */
diff --git a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceMinimumRequiredTimeProviderImpl.java b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceMinimumRequiredTimeProviderImpl.java
index 7c33d76385ab..f7935de91aae 100644
--- a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceMinimumRequiredTimeProviderImpl.java
+++ b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceMinimumRequiredTimeProviderImpl.java
@@ -24,6 +24,8 @@
 import static org.apache.ignite.internal.distributionzones.rebalance.RebalanceUtil.STABLE_ASSIGNMENTS_PREFIX_BYTES;
 import static org.apache.ignite.internal.hlc.HybridTimestamp.hybridTimestamp;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -50,6 +52,7 @@
  * {@link RebalanceMinimumRequiredTimeProvider} implementation for the current implementation of assignments. Assumes that each table has
  * its own assignments, but assignments within a zone are still somehow coordinated.
  */
+@Singleton
 public class RebalanceMinimumRequiredTimeProviderImpl implements RebalanceMinimumRequiredTimeProvider {
     private final MetaStorageManager metaStorageManager;
     private final CatalogService catalogService;
@@ -57,6 +60,7 @@ public class RebalanceMinimumRequiredTimeProviderImpl implements RebalanceMinimu
     /**
      * Constructor.
      */
+    @Inject
     public RebalanceMinimumRequiredTimeProviderImpl(MetaStorageManager metaStorageManager, CatalogService catalogService) {
         this.metaStorageManager = metaStorageManager;
         this.catalogService = catalogService;
diff --git a/modules/failure-handler/build.gradle b/modules/failure-handler/build.gradle
index aa1198168eb5..6482d10c998c 100644
--- a/modules/failure-handler/build.gradle
+++ b/modules/failure-handler/build.gradle
@@ -24,11 +24,13 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 dependencies {
     annotationProcessor libs.auto.service
     annotationProcessor project(":ignite-configuration-annotation-processor")
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-api')
     implementation project(':ignite-core')
     implementation project(':ignite-configuration-api')
     implementation project(':ignite-configuration-root')
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
 
diff --git a/modules/failure-handler/src/main/java/org/apache/ignite/internal/failure/FailureManager.java b/modules/failure-handler/src/main/java/org/apache/ignite/internal/failure/FailureManager.java
index a9e9f0741a46..a231f3ac32ed 100644
--- a/modules/failure-handler/src/main/java/org/apache/ignite/internal/failure/FailureManager.java
+++ b/modules/failure-handler/src/main/java/org/apache/ignite/internal/failure/FailureManager.java
@@ -22,6 +22,9 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCauseOrSuppressed;
 import static org.apache.ignite.lang.ErrorGroups.Common.COMPONENT_NOT_STARTED_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.EnumMap;
 import java.util.EnumSet;
 import java.util.Map;
@@ -29,6 +32,9 @@
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.configuration.notifications.ConfigurationListener;
 import org.apache.ignite.configuration.notifications.ConfigurationNotificationEvent;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorView;
 import org.apache.ignite.internal.failure.handlers.AbstractFailureHandler;
@@ -53,6 +59,9 @@
 /**
  * General failure processing implementation.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(600)
 public class FailureManager implements FailureProcessor, IgniteComponent {
     /** Logger. */
     private static final IgniteLogger LOG = Loggers.forClass(FailureManager.class);
@@ -118,12 +127,25 @@ public FailureManager(FailureHandler handler) {
      * @param nodeStopper Node stopper.
      * @param configuration Failure processor configuration.
      */
+    @TestOnly
     public FailureManager(String nodeName, NodeStopper nodeStopper, FailureProcessorConfiguration configuration) {
         this.nodeName = nodeName;
         this.nodeStopper = nodeStopper;
         this.configuration = configuration;
     }
 
+    /**
+     * Creates a new instance of a failure processor.
+     *
+     * @param nodeIdentity Node identity.
+     * @param nodeStopper Node stopper.
+     * @param configuration Failure processor configuration.
+     */
+    @Inject
+    public FailureManager(NodeIdentity nodeIdentity, NodeStopper nodeStopper, FailureProcessorConfiguration configuration) {
+        this(nodeIdentity.nodeName(), nodeStopper, configuration);
+    }
+
     @Override
     public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
         initFailureHandler();
diff --git a/modules/index/build.gradle b/modules/index/build.gradle
index 7313e8efd76d..a018ffe307d4 100644
--- a/modules/index/build.gradle
+++ b/modules/index/build.gradle
@@ -23,6 +23,7 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 dependencies {
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-api')
     implementation project(':ignite-catalog')
@@ -35,14 +36,17 @@ dependencies {
     implementation project(':ignite-network-api')
     implementation project(':ignite-raft-api')
     implementation project(':ignite-metastorage-api')
+    implementation project(':ignite-metastorage')
     implementation project(':ignite-placement-driver-api')
     implementation project(':ignite-replicator')
     implementation project(':ignite-cluster-management')
     implementation project(':ignite-low-watermark')
     implementation project(':ignite-partition-replicator')
     implementation project(':ignite-partition-distribution')
+    implementation project(':ignite-system-view-api')
     implementation project(':ignite-failure-handler')
     implementation libs.jetbrains.annotations
+    implementation libs.micronaut.inject
 
     testImplementation testFixtures(project(':ignite-configuration'))
     testImplementation testFixtures(project(':ignite-core'))
diff --git a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexBuildingManager.java b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexBuildingManager.java
index 6c640ae740a4..0a04f3d64763 100644
--- a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexBuildingManager.java
+++ b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexBuildingManager.java
@@ -25,6 +25,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.internal.util.IgniteUtils.shutdownAndAwaitTermination;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
@@ -34,6 +37,9 @@
 import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogIndexStatus;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -62,6 +68,9 @@
  *
  * @see CatalogIndexDescriptor#status()
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2700)
 public class IndexBuildingManager implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(IndexBuildingManager.class);
 
@@ -81,6 +90,43 @@ public class IndexBuildingManager implements IgniteComponent {
 
     private final AtomicBoolean stopGuard = new AtomicBoolean();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public IndexBuildingManager(
+            ClusterService clusterService,
+            ReplicaService replicaService,
+            CatalogManager catalogManager,
+            MetaStorageManager metaStorageManager,
+            IndexManager indexManager,
+            IndexMetaStorage indexMetaStorage,
+            PlacementDriver placementDriver,
+            LogicalTopologyService logicalTopologyService,
+            ClockService clockService,
+            FailureManager failureManager,
+            LowWatermark lowWatermark,
+            TxManager txManager,
+            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            MetricManager metricManager
+    ) {
+        this(
+                clusterService.nodeName(),
+                replicaService,
+                catalogManager,
+                metaStorageManager,
+                indexManager,
+                indexMetaStorage,
+                placementDriver,
+                clusterService,
+                logicalTopologyService,
+                clockService,
+                failureManager,
+                lowWatermark,
+                txManager,
+                partitionReplicaLifecycleManager,
+                metricManager
+        );
+    }
+
     /** Constructor. */
     public IndexBuildingManager(
             String nodeName,
diff --git a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexManager.java b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexManager.java
index ffd00ef62b13..d1d14e93147c 100644
--- a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexManager.java
+++ b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexManager.java
@@ -30,6 +30,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
@@ -45,6 +49,8 @@
 import org.apache.ignite.internal.catalog.events.RemoveIndexEventParameters;
 import org.apache.ignite.internal.causality.IncrementalVersionedValue;
 import org.apache.ignite.internal.causality.RevisionListenerRegistry;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -70,6 +76,9 @@
  * <p>To avoid errors when using indexes while applying replication log during node recovery, the registration of indexes was moved to the
  * start of the tables.</p>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2600)
 public class IndexManager implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(IndexManager.class);
 
@@ -108,12 +117,15 @@ public class IndexManager implements IgniteComponent {
      * @param tableManager Table manager.
      * @param catalogService Catalog service.
      * @param ioExecutor Separate executor for IO operations like storage initialization.
+     * @param registry Revision listener registry.
+     * @param lowWatermark Low watermark.
      */
+    @Inject
     public IndexManager(
             SchemaManager schemaManager,
             TableManager tableManager,
             CatalogService catalogService,
-            ExecutorService ioExecutor,
+            @Named("tableIoExecutor") ExecutorService ioExecutor,
             RevisionListenerRegistry registry,
             LowWatermark lowWatermark
     ) {
diff --git a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java
index f01b1faaffa0..6e7a1856ca6e 100644
--- a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java
+++ b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java
@@ -21,6 +21,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.NavigableMap;
@@ -32,6 +35,8 @@
 import java.util.function.Supplier;
 import org.apache.ignite.internal.catalog.Catalog;
 import org.apache.ignite.internal.catalog.CatalogService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.index.message.IndexMessageGroup;
@@ -52,6 +57,8 @@
  * Local node RW transaction completion checker for indexes. Main task is to handle the
  * {@link IsNodeFinishedRwTransactionsStartedBeforeRequest}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
 public class IndexNodeFinishedRwTransactionsChecker implements LocalRwTxCounter, ActiveLocalTxMinimumRequiredTimeProvider,
         IgniteComponent {
     private static final IndexMessagesFactory FACTORY = new IndexMessagesFactory();
@@ -73,9 +80,10 @@ public class IndexNodeFinishedRwTransactionsChecker implements LocalRwTxCounter,
     private final AtomicBoolean stopGuard = new AtomicBoolean();
 
     /** Constructor. */
+    @Inject
     public IndexNodeFinishedRwTransactionsChecker(
             CatalogService catalogService,
-            MessagingService messagingService,
+            @Named("clusterMessaging") MessagingService messagingService,
             HybridClock clock
     ) {
         this.catalogService = catalogService;
diff --git a/modules/low-watermark/build.gradle b/modules/low-watermark/build.gradle
index efff3fe15901..89046eb1410e 100644
--- a/modules/low-watermark/build.gradle
+++ b/modules/low-watermark/build.gradle
@@ -23,9 +23,11 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.auto.service
 
     implementation project(':ignite-core')
+    implementation libs.micronaut.inject
     implementation project(':ignite-failure-handler')
     implementation project(':ignite-network-api')
     implementation project(':ignite-vault')
diff --git a/modules/low-watermark/src/main/java/org/apache/ignite/internal/lowwatermark/LowWatermarkImpl.java b/modules/low-watermark/src/main/java/org/apache/ignite/internal/lowwatermark/LowWatermarkImpl.java
index 5af9e48fe928..d79fced48a0c 100644
--- a/modules/low-watermark/src/main/java/org/apache/ignite/internal/lowwatermark/LowWatermarkImpl.java
+++ b/modules/low-watermark/src/main/java/org/apache/ignite/internal/lowwatermark/LowWatermarkImpl.java
@@ -27,6 +27,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -42,6 +46,9 @@
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Consumer;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.event.AbstractEventProducer;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureManager;
@@ -91,6 +98,9 @@
  *
  * @see LowWatermarkEvent
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(2000)
 public class LowWatermarkImpl extends AbstractEventProducer<LowWatermarkEvent, LowWatermarkEventParameters> implements LowWatermark,
         IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(LowWatermarkImpl.class);
@@ -133,6 +143,19 @@ public class LowWatermarkImpl extends AbstractEventProducer<LowWatermarkEvent, L
 
     private final Lock scheduleUpdateLowWatermarkTaskLock = new ReentrantLock();
 
+    /** Constructor for DI. */
+    @Inject
+    public LowWatermarkImpl(
+            NodeIdentity nodeIdentity,
+            LowWatermarkConfiguration lowWatermarkConfig,
+            ClockService clockService,
+            VaultManager vaultManager,
+            FailureManager failureManager,
+            @Named("clusterMessaging") MessagingService messagingService
+    ) {
+        this(nodeIdentity.nodeName(), lowWatermarkConfig, clockService, vaultManager, failureManager, messagingService);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/metastorage/build.gradle b/modules/metastorage/build.gradle
index bf0c0a4fe85f..fd39fc3c9eba 100644
--- a/modules/metastorage/build.gradle
+++ b/modules/metastorage/build.gradle
@@ -43,6 +43,8 @@ dependencies {
     implementation libs.auto.service.annotations
 
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
+    implementation libs.micronaut.inject
 
     testImplementation testFixtures(project(':ignite-core'))
     testImplementation testFixtures(project(':ignite-vault'))
@@ -93,6 +95,7 @@ dependencies {
     testFixturesImplementation testFixtures(project(':ignite-core'))
     testFixturesImplementation testFixtures(project(':ignite-failure-handler'))
     testFixturesImplementation testFixtures(project(':ignite-metrics'))
+    testFixturesImplementation libs.micronaut.inject
 }
 
 description = 'ignite-metastorage'
diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageCompactionTrigger.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageCompactionTrigger.java
index 222a1deb0c86..4f8b5a92640b 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageCompactionTrigger.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageCompactionTrigger.java
@@ -26,6 +26,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockSafe;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 import java.util.concurrent.RejectedExecutionException;
@@ -36,6 +39,9 @@
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Function;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
@@ -80,6 +86,9 @@
  *     in the {@link MetaStorageManager#deployWatches}.</li>
  * </ul>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(3400)
 public class MetaStorageCompactionTrigger implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(MetaStorageCompactionTrigger.class);
 
@@ -117,6 +126,35 @@ public class MetaStorageCompactionTrigger implements IgniteComponent {
 
     private final AtomicBoolean stopGuard = new AtomicBoolean();
 
+    /**
+     * Constructor for dependency injection.
+     *
+     * @param nodeIdentity Node identity.
+     * @param storage Storage.
+     * @param metaStorageManager Metastorage manager.
+     * @param failureProcessor Failure processor.
+     * @param readOperationForCompactionTracker Tracker of read operations, both local and from the leader.
+     * @param systemDistributedConfig Distributed system configuration.
+     */
+    @Inject
+    public MetaStorageCompactionTrigger(
+            NodeIdentity nodeIdentity,
+            KeyValueStorage storage,
+            MetaStorageManager metaStorageManager,
+            FailureProcessor failureProcessor,
+            ReadOperationForCompactionTracker readOperationForCompactionTracker,
+            SystemDistributedConfiguration systemDistributedConfig
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                storage,
+                (MetaStorageManagerImpl) metaStorageManager,
+                failureProcessor,
+                readOperationForCompactionTracker,
+                systemDistributedConfig
+        );
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageManagerImpl.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageManagerImpl.java
index 20cc515ff44b..b6be340cef25 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageManagerImpl.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageManagerImpl.java
@@ -28,6 +28,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -50,6 +54,8 @@
 import org.apache.ignite.internal.cluster.management.ClusterState;
 import org.apache.ignite.internal.cluster.management.MetaStorageInfo;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.disaster.system.message.ResetClusterMessage;
 import org.apache.ignite.internal.disaster.system.repair.MetastorageRepair;
@@ -128,6 +134,9 @@
  *     <li>Providing corresponding Meta storage service proxy interface</li>
  * </ul>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(200)
 public class MetaStorageManagerImpl implements MetaStorageManager, MetastorageGroupMaintenance {
     private static final IgniteLogger LOG = Loggers.forClass(MetaStorageManagerImpl.class);
 
@@ -233,6 +242,7 @@ public class MetaStorageManagerImpl implements MetaStorageManager, MetastorageGr
      * @param ioExecutor Executor to which I/O operations can be offloaded from network threads.
      * @param failureProcessor Failure processor to use when reporting failures.
      */
+    @Inject
     public MetaStorageManagerImpl(
             ClusterService clusterService,
             ClusterManagementGroupManager cmgMgr,
@@ -244,9 +254,9 @@ public MetaStorageManagerImpl(
             MetricManager metricManager,
             MetastorageRepairStorage metastorageRepairStorage,
             MetastorageRepair metastorageRepair,
-            RaftGroupOptionsConfigurer raftGroupOptionsConfigurer,
+            @Named("metastorage") RaftGroupOptionsConfigurer raftGroupOptionsConfigurer,
             ReadOperationForCompactionTracker readOperationForCompactionTracker,
-            Executor ioExecutor,
+            @Named("tableIoExecutor") Executor ioExecutor,
             FailureProcessor failureProcessor
     ) {
         this.clusterService = clusterService;
diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageRevisionListenerRegistry.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageRevisionListenerRegistry.java
index e2a5c78c119c..b7f208b8aa5d 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageRevisionListenerRegistry.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageRevisionListenerRegistry.java
@@ -17,11 +17,13 @@
 
 package org.apache.ignite.internal.metastorage.impl;
 
+import jakarta.inject.Singleton;
 import org.apache.ignite.internal.causality.RevisionListener;
 import org.apache.ignite.internal.causality.RevisionListenerRegistry;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
 
 /** Implementation based on {@link MetaStorageManager}. */
+@Singleton
 public class MetaStorageRevisionListenerRegistry implements RevisionListenerRegistry {
     private final MetaStorageManager metaStorageManager;
 
diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/ReadOperationForCompactionTracker.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/ReadOperationForCompactionTracker.java
index 2baae964773a..9a5586b52825 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/ReadOperationForCompactionTracker.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/ReadOperationForCompactionTracker.java
@@ -20,6 +20,7 @@
 import static java.util.stream.Collectors.collectingAndThen;
 import static java.util.stream.Collectors.toList;
 
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.CompletableFuture;
@@ -45,6 +46,7 @@
  *     ({@link KeyValueStorage#setCompactionRevision}) for a new compaction revision.</li>
  * </ul>
  */
+@Singleton
 public class ReadOperationForCompactionTracker {
     private final Map<ReadOperationKey, CompletableFuture<Void>> readOperationFutureByKey = new ConcurrentHashMap<>();
 
diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/persistence/RocksDbKeyValueStorage.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/persistence/RocksDbKeyValueStorage.java
index c5c2f1f8f3ae..de92b4b418d2 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/persistence/RocksDbKeyValueStorage.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/persistence/RocksDbKeyValueStorage.java
@@ -56,6 +56,9 @@
 import static org.apache.ignite.lang.ErrorGroups.MetaStorage.STARTING_STORAGE_ERR;
 import static org.rocksdb.util.SizeUnit.MB;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
@@ -77,6 +80,8 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.LongSupplier;
 import org.apache.ignite.internal.components.NoOpLogSyncer;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -147,6 +152,7 @@
  * The mapping from the key to the set of the storage's revisions is stored in the "index" column family. A key represents the key of an
  * entry and the value is a {@code byte[]} that represents a {@code long[]} where every item is a revision of the storage.
  */
+@Singleton
 public class RocksDbKeyValueStorage extends AbstractKeyValueStorage {
     private static final IgniteLogger LOG = Loggers.forClass(RocksDbKeyValueStorage.class);
 
@@ -286,6 +292,20 @@ private enum RecoveryStatus {
 
     private final AtomicBoolean closeGuard = new AtomicBoolean();
 
+    /**
+     * DI constructor.
+     */
+    @Inject
+    public RocksDbKeyValueStorage(
+            NodeIdentity nodeIdentity,
+            @Named("metastorage") ComponentWorkingDir metastorageWorkDir,
+            FailureProcessor failureProcessor,
+            ReadOperationForCompactionTracker readOperationForCompactionTracker,
+            @Named("commonScheduler") ScheduledExecutorService scheduledExecutor
+    ) {
+        this(nodeIdentity.nodeName(), metastorageWorkDir.dbPath(), failureProcessor, readOperationForCompactionTracker, scheduledExecutor);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/metrics/build.gradle b/modules/metrics/build.gradle
index 288f8ff5fc39..da4ab0d4743e 100644
--- a/modules/metrics/build.gradle
+++ b/modules/metrics/build.gradle
@@ -31,6 +31,7 @@ dependencies {
     implementation project(':ignite-configuration-root')
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
 
     annotationProcessor libs.auto.service
 
@@ -51,6 +52,7 @@ dependencies {
     integrationTestImplementation libs.auto.service.annotations
 
     testFixturesImplementation project(':ignite-core')
+    testFixturesImplementation libs.micronaut.inject
 }
 
 description = 'ignite-metrics'
diff --git a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java
index 1ec0cd2520bf..88710e47ae97 100644
--- a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java
+++ b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java
@@ -22,6 +22,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockSafe;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.ServiceLoader;
 import java.util.ServiceLoader.Provider;
@@ -31,6 +34,9 @@
 import java.util.function.Supplier;
 import org.apache.ignite.configuration.notifications.ConfigurationNamedListListener;
 import org.apache.ignite.configuration.notifications.ConfigurationNotificationEvent;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -46,6 +52,9 @@
 /**
  * Metric manager.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(900)
 public class MetricManagerImpl extends AbstractMetricManager {
     // This field cannot be static, because its used by the Thin Client.
     // However, it is expected that MetricManagerImpl will be used only on the server side.
@@ -63,6 +72,12 @@ public MetricManagerImpl(String nodeName, Supplier<UUID> clusterIdSupplier) {
         this.clusterIdSupplier = clusterIdSupplier;
     }
 
+    /** Constructor for DI injection. */
+    @Inject
+    public MetricManagerImpl(NodeIdentity nodeIdentity) {
+        this(nodeIdentity.nodeName(), nodeIdentity.clusterIdSupplier());
+    }
+
     /** Constructor for smoother testing. */
     @TestOnly
     public MetricManagerImpl(String nodeName, Supplier<UUID> clusterIdSupplier, MetricConfiguration metricConfiguration) {
diff --git a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/sources/ClockServiceMetricSource.java b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/sources/ClockServiceMetricSource.java
index edfb9893f371..c986c41f81f5 100644
--- a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/sources/ClockServiceMetricSource.java
+++ b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/sources/ClockServiceMetricSource.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.metrics.sources;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import org.apache.ignite.internal.metrics.AbstractMetricSource;
 import org.apache.ignite.internal.metrics.DistributionMetric;
@@ -26,6 +27,7 @@
 /**
  * Metric source, which provides clock service metrics.
  */
+@Singleton
 public class ClockServiceMetricSource extends AbstractMetricSource<Holder> {
     /** Source name. */
     public static final String SOURCE_NAME = "clock.service";
diff --git a/modules/network/build.gradle b/modules/network/build.gradle
index bf931fa03ccd..ee392540e9df 100644
--- a/modules/network/build.gradle
+++ b/modules/network/build.gradle
@@ -43,11 +43,13 @@ dependencies {
     implementation libs.jackson.core
     implementation libs.jackson.databind
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
     compileOnly libs.jsr305 // Fix unknown enum constant warning
 
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     testAnnotationProcessor project(':ignite-network-annotation-processor')
     testAnnotationProcessor libs.jmh.annotation.processor
@@ -72,6 +74,7 @@ dependencies {
     testImplementation libs.bouncycastle.bcpkix.jdk18on;
 
     testFixturesAnnotationProcessor project(':ignite-network-annotation-processor')
+    testFixturesImplementation libs.micronaut.inject
     testFixturesImplementation project(':ignite-configuration')
     testFixturesImplementation project(':ignite-configuration-root')
     testFixturesImplementation project(':ignite-failure-handler')
diff --git a/modules/network/src/main/java/org/apache/ignite/internal/network/MessageSerializationRegistryImpl.java b/modules/network/src/main/java/org/apache/ignite/internal/network/MessageSerializationRegistryImpl.java
index 158ca8af95fe..5a0edff17e7b 100644
--- a/modules/network/src/main/java/org/apache/ignite/internal/network/MessageSerializationRegistryImpl.java
+++ b/modules/network/src/main/java/org/apache/ignite/internal/network/MessageSerializationRegistryImpl.java
@@ -17,19 +17,35 @@
 
 package org.apache.ignite.internal.network;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.network.serialization.MessageDeserializer;
 import org.apache.ignite.internal.network.serialization.MessageSerializationFactory;
 import org.apache.ignite.internal.network.serialization.MessageSerializationRegistry;
 import org.apache.ignite.internal.network.serialization.MessageSerializer;
+import org.apache.ignite.internal.network.serialization.SerializationRegistryServiceLoader;
 
 /**
  * Default implementation of a {@link MessageSerializationRegistry}.
  */
+@Singleton
 public class MessageSerializationRegistryImpl implements MessageSerializationRegistry {
     /** group type → message type → MessageSerializerProvider instance. */
     private final MessageSerializationFactory<?>[][] factories =
             new MessageSerializationFactory<?>[Short.MAX_VALUE + 1][];
 
+    /** Default constructor for direct use in tests. */
+    public MessageSerializationRegistryImpl() {
+    }
+
+    /** DI constructor that loads and registers all serialization factories from the classpath. */
+    @Inject
+    public MessageSerializationRegistryImpl(NodeIdentity nodeIdentity) {
+        var serviceLoader = new SerializationRegistryServiceLoader(nodeIdentity.serviceProviderClassLoader());
+        serviceLoader.registerSerializationFactories(this);
+    }
+
     @Override
     public MessageSerializationRegistry registerFactory(
             short groupType, short messageType, MessageSerializationFactory<?> factory
diff --git a/modules/network/src/main/java/org/apache/ignite/internal/network/NettyBootstrapFactory.java b/modules/network/src/main/java/org/apache/ignite/internal/network/NettyBootstrapFactory.java
index f2bcff10105a..ef79e028a96f 100644
--- a/modules/network/src/main/java/org/apache/ignite/internal/network/NettyBootstrapFactory.java
+++ b/modules/network/src/main/java/org/apache/ignite/internal/network/NettyBootstrapFactory.java
@@ -21,6 +21,7 @@
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.ChannelOption;
@@ -29,9 +30,14 @@
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.channel.socket.nio.NioSocketChannel;
 import io.netty.util.concurrent.EventExecutor;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 import org.apache.ignite.internal.network.configuration.InboundView;
@@ -46,6 +52,9 @@
 /**
  * Netty bootstrap factory. Holds shared {@link EventLoopGroup} instances and encapsulates common Netty {@link Bootstrap} creation logic.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1100)
 public class NettyBootstrapFactory implements IgniteComponent {
     /** Network configuration. */
     private final NetworkConfiguration networkConfiguration;
@@ -61,6 +70,12 @@ public class NettyBootstrapFactory implements IgniteComponent {
 
     private volatile HandshakeEventLoopSwitcher handshakeEventLoopSwitcher;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public NettyBootstrapFactory(NetworkConfiguration networkConfiguration, NodeIdentity nodeIdentity) {
+        this(networkConfiguration, nodeIdentity.nodeName());
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/network/src/main/java/org/apache/ignite/internal/network/NettyWorkersRegistrar.java b/modules/network/src/main/java/org/apache/ignite/internal/network/NettyWorkersRegistrar.java
index 733036183ce5..326ab4ec9d01 100644
--- a/modules/network/src/main/java/org/apache/ignite/internal/network/NettyWorkersRegistrar.java
+++ b/modules/network/src/main/java/org/apache/ignite/internal/network/NettyWorkersRegistrar.java
@@ -20,9 +20,13 @@
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
 import io.netty.channel.EventLoopGroup;
 import io.netty.util.concurrent.EventExecutor;
 import io.netty.util.concurrent.SingleThreadEventExecutor;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -30,6 +34,8 @@
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.failure.FailureType;
@@ -45,6 +51,9 @@
 /**
  * This component is responsible for registering Netty workers with the {@link CriticalWorkerRegistry} and for updating their heartbeats.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1200)
 public class NettyWorkersRegistrar implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(NettyWorkersRegistrar.class);
 
@@ -78,9 +87,10 @@ public class NettyWorkersRegistrar implements IgniteComponent {
      * @param bootstrapFactory Used to obtain Netty workers.
      * @param failureManager Used to process failures.
      */
+    @Inject
     public NettyWorkersRegistrar(
             CriticalWorkerRegistry criticalWorkerRegistry,
-            ScheduledExecutorService scheduler,
+            @Named("commonScheduler") ScheduledExecutorService scheduler,
             NettyBootstrapFactory bootstrapFactory,
             CriticalWorkersConfiguration criticalWorkersConfiguration,
             FailureManager failureManager
diff --git a/modules/network/src/main/java/org/apache/ignite/internal/network/scalecube/ScaleCubeClusterService.java b/modules/network/src/main/java/org/apache/ignite/internal/network/scalecube/ScaleCubeClusterService.java
index 62a4fb881f7f..0ba2bf51b20c 100644
--- a/modules/network/src/main/java/org/apache/ignite/internal/network/scalecube/ScaleCubeClusterService.java
+++ b/modules/network/src/main/java/org/apache/ignite/internal/network/scalecube/ScaleCubeClusterService.java
@@ -22,12 +22,15 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Network.ADDRESS_UNRESOLVED_ERR;
 
+import io.micronaut.core.annotation.Order;
 import io.scalecube.cluster.ClusterConfig;
 import io.scalecube.cluster.ClusterImpl;
 import io.scalecube.cluster.ClusterMessageHandler;
 import io.scalecube.cluster.membership.MembershipEvent;
 import io.scalecube.cluster.metadata.MetadataCodec;
 import io.scalecube.net.Address;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
@@ -41,6 +44,9 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -48,6 +54,7 @@
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ChannelTypeRegistry;
+import org.apache.ignite.internal.network.ChannelTypeRegistryProvider;
 import org.apache.ignite.internal.network.ClusterIdSupplier;
 import org.apache.ignite.internal.network.ClusterNodeImpl;
 import org.apache.ignite.internal.network.ClusterService;
@@ -65,6 +72,7 @@
 import org.apache.ignite.internal.network.configuration.NetworkView;
 import org.apache.ignite.internal.network.configuration.ScaleCubeView;
 import org.apache.ignite.internal.network.netty.ConnectionManager;
+import org.apache.ignite.internal.network.recovery.InMemoryStaleIds;
 import org.apache.ignite.internal.network.recovery.StaleIds;
 import org.apache.ignite.internal.network.serialization.ClassDescriptorFactory;
 import org.apache.ignite.internal.network.serialization.ClassDescriptorRegistry;
@@ -73,6 +81,7 @@
 import org.apache.ignite.internal.network.serialization.UserObjectSerializationContext;
 import org.apache.ignite.internal.network.serialization.marshal.DefaultUserObjectMarshaller;
 import org.apache.ignite.internal.util.IgniteUtils;
+import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
 import org.apache.ignite.internal.version.IgniteProductVersionSource;
 import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
 import org.apache.ignite.lang.IgniteException;
@@ -83,6 +92,9 @@
 /**
  * ScaleCube-based implementation of {@link ClusterService}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1300)
 public class ScaleCubeClusterService implements ClusterService {
     private static final IgniteLogger LOG = Loggers.forClass(ScaleCubeClusterService.class);
 
@@ -109,6 +121,33 @@ public class ScaleCubeClusterService implements ClusterService {
     @Nullable
     private volatile ClusterImpl cluster;
 
+    /** DI constructor that resolves NodeIdentity and creates inline dependencies. */
+    @Inject
+    public ScaleCubeClusterService(
+            NodeIdentity nodeIdentity,
+            NetworkConfiguration networkConfiguration,
+            NettyBootstrapFactory nettyBootstrapFactory,
+            MessageSerializationRegistry serializationRegistry,
+            ClusterIdSupplier clusterIdSupplier,
+            CriticalWorkerRegistry criticalWorkerRegistry,
+            FailureProcessor failureProcessor,
+            MetricManager metricManager
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                networkConfiguration,
+                nettyBootstrapFactory,
+                serializationRegistry,
+                new InMemoryStaleIds(),
+                clusterIdSupplier,
+                criticalWorkerRegistry,
+                failureProcessor,
+                ChannelTypeRegistryProvider.loadByServiceLoader(nodeIdentity.serviceProviderClassLoader()),
+                new DefaultIgniteProductVersionSource(),
+                metricManager
+        );
+    }
+
     /** Constructor. */
     public ScaleCubeClusterService(
             String consistentId,
diff --git a/modules/network/src/testFixtures/java/org/apache/ignite/internal/network/utils/ClusterServiceTestUtils.java b/modules/network/src/testFixtures/java/org/apache/ignite/internal/network/utils/ClusterServiceTestUtils.java
index 35e1c142aaab..1cad6a856e42 100644
--- a/modules/network/src/testFixtures/java/org/apache/ignite/internal/network/utils/ClusterServiceTestUtils.java
+++ b/modules/network/src/testFixtures/java/org/apache/ignite/internal/network/utils/ClusterServiceTestUtils.java
@@ -28,6 +28,7 @@
 import java.util.stream.IntStream;
 import org.apache.ignite.configuration.annotation.ConfigurationType;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
@@ -213,7 +214,7 @@ private static ClusterService clusterService(
                 List.of(NetworkExtensionConfigurationSchema.class),
                 List.of(StaticNodeFinderConfigurationSchema.class, MulticastNodeFinderConfigurationSchema.class)
         );
-        ConfigurationRegistry nodeConfigurationRegistry = new ConfigurationRegistry(
+        ConfigurationRegistry nodeConfigurationRegistry = new ConfigurationRegistryImpl(
                 Collections.singleton(NodeConfiguration.KEY),
                 new TestConfigurationStorage(ConfigurationType.LOCAL),
                 generator,
diff --git a/modules/partition-replicator/build.gradle b/modules/partition-replicator/build.gradle
index bd5deaaf6666..cca4cbcf77b8 100644
--- a/modules/partition-replicator/build.gradle
+++ b/modules/partition-replicator/build.gradle
@@ -23,7 +23,9 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 
 dependencies {
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
 
     implementation project(':ignite-core')
diff --git a/modules/partition-replicator/src/integrationTest/java/org/apache/ignite/internal/partition/replicator/fixtures/Node.java b/modules/partition-replicator/src/integrationTest/java/org/apache/ignite/internal/partition/replicator/fixtures/Node.java
index e5293fd5b420..4fa6fd97bc74 100644
--- a/modules/partition-replicator/src/integrationTest/java/org/apache/ignite/internal/partition/replicator/fixtures/Node.java
+++ b/modules/partition-replicator/src/integrationTest/java/org/apache/ignite/internal/partition/replicator/fixtures/Node.java
@@ -72,6 +72,7 @@
 import org.apache.ignite.internal.configuration.ClusterConfiguration;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
@@ -370,7 +371,7 @@ public Node(
         Path configPath = dir.resolve("config");
         TestIgnitionManager.writeConfigurationFileApplyingTestDefaults(configPath);
 
-        nodeConfigRegistry = new ConfigurationRegistry(
+        nodeConfigRegistry = new ConfigurationRegistryImpl(
                 List.of(NodeConfiguration.KEY),
                 new LocalFileConfigurationStorage(configPath, nodeCfgGenerator, null),
                 nodeCfgGenerator,
@@ -577,7 +578,7 @@ public CompletableFuture<Boolean> invoke(Condition condition, Operation success,
                 List.of()
         );
 
-        clusterConfigRegistry = new ConfigurationRegistry(
+        clusterConfigRegistry = new ConfigurationRegistryImpl(
                 List.of(ClusterConfiguration.KEY),
                 cfgStorage,
                 clusterCfgGenerator,
diff --git a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/PartitionReplicaLifecycleManager.java b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/PartitionReplicaLifecycleManager.java
index e66bdea72899..b7a537746bbd 100644
--- a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/PartitionReplicaLifecycleManager.java
+++ b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/PartitionReplicaLifecycleManager.java
@@ -75,7 +75,11 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -104,6 +108,8 @@
 import org.apache.ignite.internal.catalog.descriptors.ConsistencyMode;
 import org.apache.ignite.internal.catalog.events.CreateZoneEventParameters;
 import org.apache.ignite.internal.catalog.events.DropZoneEventParameters;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
@@ -205,6 +211,9 @@
  *     <li>Supporting the rebalance mechanism and starting the new replication nodes when the rebalance triggers occurred.</li>
  * </ul>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2300)
 public class PartitionReplicaLifecycleManager extends
         AbstractEventProducer<LocalPartitionReplicaEvent, LocalPartitionReplicaEventParameters> implements IgniteComponent {
     private final CatalogService catalogService;
@@ -325,6 +334,7 @@ public class PartitionReplicaLifecycleManager extends
      * @param messagingService Messaging service.
      * @param replicaService Replica service.
      */
+    @Inject
     public PartitionReplicaLifecycleManager(
             CatalogService catalogService,
             ReplicaManager replicaMgr,
@@ -333,9 +343,9 @@ public PartitionReplicaLifecycleManager(
             TopologyService topologyService,
             LowWatermark lowWatermark,
             FailureProcessor failureProcessor,
-            ExecutorService ioExecutor,
-            ScheduledExecutorService rebalanceScheduler,
-            Executor partitionOperationsExecutor,
+            @Named("tableIoExecutor") ExecutorService ioExecutor,
+            @Named("rebalanceScheduler") ScheduledExecutorService rebalanceScheduler,
+            @Named("partitionOperationsExecutor") Executor partitionOperationsExecutor,
             ClockService clockService,
             PlacementDriver placementDriver,
             SchemaSyncService schemaSyncService,
@@ -346,7 +356,7 @@ public PartitionReplicaLifecycleManager(
             DataStorageManager dataStorageManager,
             OutgoingSnapshotsManager outgoingSnapshotsManager,
             MetricManager metricManager,
-            MessagingService messagingService,
+            @Named("storageOperations") MessagingService messagingService,
             ReplicaService replicaService
     ) {
         this(
diff --git a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManager.java b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManager.java
index fde77ca77bd8..f75cef5b3cc2 100644
--- a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManager.java
+++ b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManager.java
@@ -24,6 +24,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -34,6 +38,9 @@
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.lang.NodeStoppingException;
@@ -58,6 +65,9 @@
 /**
  * Outgoing snapshots manager. Manages a collection of all outgoing snapshots, currently present on the Ignite node.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2100)
 public class OutgoingSnapshotsManager implements PartitionsSnapshots, IgniteComponent {
     /**
      * Logger.
@@ -81,6 +91,16 @@ public class OutgoingSnapshotsManager implements PartitionsSnapshots, IgniteComp
 
     private volatile ExecutorService executor;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public OutgoingSnapshotsManager(
+            NodeIdentity identity,
+            @Named("clusterMessaging") MessagingService messagingService,
+            FailureProcessor failureProcessor
+    ) {
+        this(identity.nodeName(), messagingService, failureProcessor);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/schema/CatalogValidationSchemasSource.java b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/schema/CatalogValidationSchemasSource.java
index 2dd18c495ea6..4240237dc406 100644
--- a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/schema/CatalogValidationSchemasSource.java
+++ b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/schema/CatalogValidationSchemasSource.java
@@ -19,6 +19,7 @@
 
 import static java.util.stream.Collectors.toList;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
@@ -35,6 +36,7 @@
 /**
  * An implementation over {@link CatalogService}.
  */
+@Singleton
 public class CatalogValidationSchemasSource implements ValidationSchemasSource {
     private final CatalogService catalogService;
 
diff --git a/modules/partition-replicator/src/test/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManagerTest.java b/modules/partition-replicator/src/test/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManagerTest.java
index 954c9a898305..c90c150aa1c6 100644
--- a/modules/partition-replicator/src/test/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManagerTest.java
+++ b/modules/partition-replicator/src/test/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManagerTest.java
@@ -31,6 +31,7 @@
 import java.util.UUID;
 import org.apache.ignite.internal.catalog.Catalog;
 import org.apache.ignite.internal.catalog.CatalogService;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.partition.replicator.raft.snapshot.PartitionKey;
 import org.apache.ignite.internal.partition.replicator.raft.snapshot.PartitionMvStorageAccess;
 import org.apache.ignite.internal.partition.replicator.raft.snapshot.PartitionTxStateAccess;
@@ -48,6 +49,9 @@ class OutgoingSnapshotsManagerTest extends BaseIgniteAbstractTest {
     private static final int ZONE_ID = 1;
     private static final int TABLE_ID = 2;
 
+    @Mock
+    private NodeIdentity nodeIdentity;
+
     @InjectMocks
     private OutgoingSnapshotsManager manager;
 
diff --git a/modules/raft/build.gradle b/modules/raft/build.gradle
index d9b56187f2f0..284540c92c78 100644
--- a/modules/raft/build.gradle
+++ b/modules/raft/build.gradle
@@ -53,9 +53,12 @@ dependencies {
     implementation libs.jctools.core
     implementation libs.auto.service.annotations
     implementation libs.jna
+    implementation libs.micronaut.inject
+    implementation project(':ignite-di')
 
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     testAnnotationProcessor project(':ignite-network-annotation-processor')
     testAnnotationProcessor libs.jmh.annotation.processor
@@ -82,6 +85,8 @@ dependencies {
     testFixturesImplementation testFixtures(project(':ignite-metrics'))
     testFixturesImplementation testFixtures(project(':ignite-network'))
     testFixturesImplementation testFixtures(project(':ignite-failure-handler'))
+    testFixturesImplementation project(':ignite-di')
+    testFixturesImplementation libs.micronaut.inject
 
     integrationTestAnnotationProcessor project(':ignite-network-annotation-processor')
     integrationTestAnnotationProcessor project(':ignite-configuration-annotation-processor')
diff --git a/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java b/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
index 5ab01ec725ec..3d78c636335a 100644
--- a/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
+++ b/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
@@ -20,6 +20,9 @@
 import static java.util.Objects.requireNonNullElse;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
@@ -29,6 +32,8 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
 import org.apache.ignite.internal.configuration.SystemPropertyConfiguration;
 import org.apache.ignite.internal.failure.FailureManager;
@@ -78,6 +83,9 @@
  */
 // TODO: Encapsulate RaftGroupOptions and move other methods to the RaftManager interface,
 //  see https://issues.apache.org/jira/browse/IGNITE-18273
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1800)
 public class Loza implements RaftManager {
     /** Factory. */
     public static final RaftMessagesFactory FACTORY = new RaftMessagesFactory();
@@ -156,6 +164,7 @@ public Loza(
      * @param groupStoragesDestructionIntents Storage to persist {@link StorageDestructionIntent}s.
      * @param groupStoragesContextResolver Resolver to get {@link StoragesDestructionContext}s for storage destruction.
      */
+    @Inject
     public Loza(
             ClusterService clusterNetSvc,
             MetricManager metricManager,
diff --git a/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VaultGroupStoragesDestructionIntents.java b/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VaultGroupStoragesDestructionIntents.java
index d870dab9468f..3dd8253aa948 100644
--- a/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VaultGroupStoragesDestructionIntents.java
+++ b/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VaultGroupStoragesDestructionIntents.java
@@ -19,6 +19,7 @@
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 
+import jakarta.inject.Singleton;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.ArrayList;
@@ -31,6 +32,7 @@
 import org.apache.ignite.internal.versioned.VersionedSerialization;
 
 /** Uses VaultManager to store destruction intents. */
+@Singleton
 public class VaultGroupStoragesDestructionIntents implements GroupStoragesDestructionIntents {
     private static final byte[] GROUP_STORAGE_DESTRUCTION_PREFIX = "destroy.group.storages.".getBytes(UTF_8);
     private static final ByteOrder BYTE_UTILS_BYTE_ORDER = ByteOrder.BIG_ENDIAN;
diff --git a/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VolatileLogStorageManagerCreator.java b/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VolatileLogStorageManagerCreator.java
index cce20e0b5072..f6e31ec0e8e4 100644
--- a/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VolatileLogStorageManagerCreator.java
+++ b/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VolatileLogStorageManagerCreator.java
@@ -22,6 +22,9 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.rocksdb.RocksDB.DEFAULT_COLUMN_FAMILY;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -31,6 +34,9 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
@@ -59,6 +65,9 @@
 /**
  * {@link LogStorageManagerCreator} for volatile log storage.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1300)
 public class VolatileLogStorageManagerCreator implements LogStorageManagerCreator, IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(VolatileLogStorageManagerCreator.class);
 
@@ -85,6 +94,14 @@ public class VolatileLogStorageManagerCreator implements LogStorageManagerCreato
 
     private RocksDbSizeCalculator sizeCalculator;
 
+    /**
+     * DI constructor.
+     */
+    @Inject
+    public VolatileLogStorageManagerCreator(NodeIdentity nodeIdentity) {
+        this(nodeIdentity.nodeName(), nodeIdentity.workDir().resolve("volatile-log-spillout"));
+    }
+
     /**
      * Create a new instance.
      *
diff --git a/modules/raft/src/main/java/org/apache/ignite/raft/jraft/rpc/impl/RaftGroupEventsClientListener.java b/modules/raft/src/main/java/org/apache/ignite/raft/jraft/rpc/impl/RaftGroupEventsClientListener.java
index 4be25a7c0340..6263ebb5cd74 100644
--- a/modules/raft/src/main/java/org/apache/ignite/raft/jraft/rpc/impl/RaftGroupEventsClientListener.java
+++ b/modules/raft/src/main/java/org/apache/ignite/raft/jraft/rpc/impl/RaftGroupEventsClientListener.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.raft.jraft.rpc.impl;
 
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.List;
@@ -30,6 +31,7 @@
 /**
 * Listener for Raft group events on client side.
 */
+@Singleton
 public class RaftGroupEventsClientListener {
     private static final IgniteLogger LOG = Loggers.forClass(RaftGroupEventsClientListener.class);
 
diff --git a/modules/replicator/build.gradle b/modules/replicator/build.gradle
index 4b7eacdcec6a..5327b96917c9 100644
--- a/modules/replicator/build.gradle
+++ b/modules/replicator/build.gradle
@@ -25,6 +25,7 @@ dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-core')
     implementation project(':ignite-raft')
@@ -40,6 +41,7 @@ dependencies {
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
 
     integrationTestImplementation project(':ignite-raft')
     integrationTestImplementation project(':ignite-raft-api')
diff --git a/modules/replicator/src/main/java/org/apache/ignite/internal/raft/client/TopologyAwareRaftGroupServiceFactory.java b/modules/replicator/src/main/java/org/apache/ignite/internal/raft/client/TopologyAwareRaftGroupServiceFactory.java
index d4e829166a12..f77b40d2fdf9 100644
--- a/modules/replicator/src/main/java/org/apache/ignite/internal/raft/client/TopologyAwareRaftGroupServiceFactory.java
+++ b/modules/replicator/src/main/java/org/apache/ignite/internal/raft/client/TopologyAwareRaftGroupServiceFactory.java
@@ -17,10 +17,13 @@
 
 package org.apache.ignite.internal.raft.client;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.raft.ExceptionFactory;
+import org.apache.ignite.internal.raft.Loza;
 import org.apache.ignite.internal.raft.Marshaller;
 import org.apache.ignite.internal.raft.PeersAndLearners;
 import org.apache.ignite.internal.raft.RaftServiceFactory;
@@ -33,6 +36,7 @@
 /**
  * Factory for creation {@link TopologyAwareRaftGroupService}.
  */
+@Singleton
 public class TopologyAwareRaftGroupServiceFactory implements RaftServiceFactory<TopologyAwareRaftGroupService> {
     private final ClusterService clusterService;
 
@@ -42,6 +46,18 @@ public class TopologyAwareRaftGroupServiceFactory implements RaftServiceFactory<
 
     private final RaftGroupEventsClientListener eventsClientListener;
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public TopologyAwareRaftGroupServiceFactory(
+            ClusterService clusterService,
+            LogicalTopologyService logicalTopologyService,
+            RaftGroupEventsClientListener eventsClientListener
+    ) {
+        this(clusterService, logicalTopologyService, Loza.FACTORY, eventsClientListener);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
index 9259d34beb4d..9f1384a57243 100644
--- a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
+++ b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
@@ -29,14 +29,21 @@
 import static org.apache.ignite.lang.ErrorGroups.Replicator.REPLICA_TIMEOUT_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Transactions.ACQUIRE_LOCK_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeoutException;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.network.InternalClusterNode;
@@ -58,6 +65,9 @@
 import org.jetbrains.annotations.TestOnly;
 
 /** The service is intended to execute requests on replicas. */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1600)
 public class ReplicaService {
     private static final List<Integer> RETRIABLE_ERRORS = List.of(
             ACQUIRE_LOCK_ERR,
@@ -84,6 +94,24 @@ public class ReplicaService {
     /** Replicator network message factory. */
     private static final ReplicaMessagesFactory REPLICA_MESSAGES_FACTORY = new ReplicaMessagesFactory();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public ReplicaService(
+            @Named("storageOperations") MessagingService messagingService,
+            ClockService clockService,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
+            ReplicationConfiguration replicationConfiguration,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
+    ) {
+        this(
+                messagingService,
+                clockService,
+                (Executor) partitionOperationsExecutor,
+                replicationConfiguration,
+                commonScheduler
+        );
+    }
+
     /**
      * The constructor of replica client.
      *
diff --git a/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java b/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
index 66635ddde64d..db06726d2e04 100644
--- a/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
+++ b/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
@@ -28,6 +28,7 @@
 import io.micronaut.http.HttpMethod;
 import io.micronaut.http.server.exceptions.ServerStartupException;
 import io.micronaut.http.ssl.ClientAuthentication;
+import io.micronaut.inject.BeanDefinitionReference;
 import io.micronaut.management.endpoint.health.HealthEndpoint;
 import io.micronaut.runtime.Micronaut;
 import io.micronaut.runtime.exceptions.ApplicationStartupException;
@@ -116,8 +117,23 @@ public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
         boolean sslEnabled = sslConfigurationView.enabled();
         boolean dualProtocol = restConfiguration.dualProtocol().value();
 
-        if (startServer(restConfigurationView.port(), sslConfigurationView.port(), sslEnabled, dualProtocol)) {
-            return nullCompletedFuture();
+        int maxRetries = 5;
+        for (int attempt = 0; attempt <= maxRetries; attempt++) {
+            if (startServer(restConfigurationView.port(), sslConfigurationView.port(), sslEnabled, dualProtocol)) {
+                return nullCompletedFuture();
+            }
+
+            if (attempt < maxRetries) {
+                LOG.info("REST port not yet available, retrying in 200ms"
+                        + " [HTTP port=" + httpPort + "], [HTTPS port=" + httpsPort + "]"
+                        + " [attempt=" + (attempt + 1) + "/" + maxRetries + "]");
+                try {
+                    Thread.sleep(200);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    break;
+                }
+            }
         }
 
         String msg = "Cannot start REST endpoint."
@@ -355,6 +371,9 @@ public String hostName() {
     private static class IgniteMicronaut extends Micronaut {
         private final ConversionService conversionService = new DefaultConversionService();
 
+        private static final String IGNITE_PACKAGE_PREFIX = "org.apache.ignite.internal.";
+        private static final String REST_PACKAGE_PREFIX = "org.apache.ignite.internal.rest.";
+
         @Override
         protected ApplicationContext newApplicationContext() {
             return new DefaultApplicationContext(this) {
@@ -362,6 +381,20 @@ protected ApplicationContext newApplicationContext() {
                 protected ConversionService createConversionService() {
                     return conversionService;
                 }
+
+                @Override
+                protected List<BeanDefinitionReference> resolveBeanDefinitionReferences() {
+                    List<BeanDefinitionReference> refs = super.resolveBeanDefinitionReferences();
+
+                    // Exclude Ignite beans that are not in the REST package to prevent
+                    // duplicate bean registration (REST factories register them explicitly).
+                    refs.removeIf(ref -> {
+                        String name = ref.getBeanDefinitionName();
+                        return name.startsWith(IGNITE_PACKAGE_PREFIX) && !name.startsWith(REST_PACKAGE_PREFIX);
+                    });
+
+                    return refs;
+                }
             };
         }
 
diff --git a/modules/rest/src/main/java/org/apache/ignite/internal/rest/configuration/PresentationsFactory.java b/modules/rest/src/main/java/org/apache/ignite/internal/rest/configuration/PresentationsFactory.java
index dff54efbd92e..ab9d751e75b8 100644
--- a/modules/rest/src/main/java/org/apache/ignite/internal/rest/configuration/PresentationsFactory.java
+++ b/modules/rest/src/main/java/org/apache/ignite/internal/rest/configuration/PresentationsFactory.java
@@ -34,7 +34,10 @@ public class PresentationsFactory implements RestFactory {
     private ConfigurationPresentation<String> nodeCfgPresentation;
     private ConfigurationPresentation<String> clusterCfgPresentation;
 
-    public PresentationsFactory(ConfigurationRegistry nodeConfigRegistry, ConfigurationRegistry clusterConfigRegistry) {
+    public PresentationsFactory(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry,
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
         this.nodeCfgPresentation = new HoconPresentation(nodeConfigRegistry);
         this.clusterCfgPresentation = new HoconPresentation(clusterConfigRegistry);
     }
diff --git a/modules/rest/src/test/java/org/apache/ignite/internal/rest/RestComponentTest.java b/modules/rest/src/test/java/org/apache/ignite/internal/rest/RestComponentTest.java
index 1071664048ec..305653e9f35e 100644
--- a/modules/rest/src/test/java/org/apache/ignite/internal/rest/RestComponentTest.java
+++ b/modules/rest/src/test/java/org/apache/ignite/internal/rest/RestComponentTest.java
@@ -40,6 +40,7 @@
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.ClusterState;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
@@ -93,7 +94,7 @@ public void setup() {
                 List.of(RestExtensionConfigurationSchema.class, NetworkExtensionConfigurationSchema.class),
                 List.of(StaticNodeFinderConfigurationSchema.class, MulticastNodeFinderConfigurationSchema.class)
         );
-        var configurationRegistry = new ConfigurationRegistry(
+        var configurationRegistry = new ConfigurationRegistryImpl(
                 List.of(NodeConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/rest/src/test/java/org/apache/ignite/internal/rest/configuration/TestFactory.java b/modules/rest/src/test/java/org/apache/ignite/internal/rest/configuration/TestFactory.java
index 7073b05e4db1..cdaded7f96ca 100644
--- a/modules/rest/src/test/java/org/apache/ignite/internal/rest/configuration/TestFactory.java
+++ b/modules/rest/src/test/java/org/apache/ignite/internal/rest/configuration/TestFactory.java
@@ -32,6 +32,7 @@
 import org.apache.ignite.configuration.validation.ValidationIssue;
 import org.apache.ignite.configuration.validation.Validator;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
@@ -60,7 +61,7 @@ public void validate(Value annotation, ValidationContext<Object> ctx) {
 
         var generator = new ConfigurationTreeGenerator(TestRootConfiguration.KEY);
 
-        var configurationRegistry = new ConfigurationRegistry(
+        var configurationRegistry = new ConfigurationRegistryImpl(
                 List.of(TestRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/runner/build.gradle b/modules/runner/build.gradle
index fb38f6c2eace..cc361e23ef03 100644
--- a/modules/runner/build.gradle
+++ b/modules/runner/build.gradle
@@ -97,6 +97,7 @@ dependencies {
     implementation project(':ignite-system-disaster-recovery')
     implementation project(':ignite-system-disaster-recovery-api')
     implementation project(':ignite-configuration-storage')
+    implementation project(':ignite-di')
     implementation libs.jetbrains.annotations
     implementation libs.micronaut.inject
     implementation libs.micronaut.validation
diff --git a/modules/runner/src/defaultsGenerator/java/org/apache/ignite/internal/configuration/generator/DefaultsGenerator.java b/modules/runner/src/defaultsGenerator/java/org/apache/ignite/internal/configuration/generator/DefaultsGenerator.java
index b3de927cc96e..b31e77268cad 100644
--- a/modules/runner/src/defaultsGenerator/java/org/apache/ignite/internal/configuration/generator/DefaultsGenerator.java
+++ b/modules/runner/src/defaultsGenerator/java/org/apache/ignite/internal/configuration/generator/DefaultsGenerator.java
@@ -28,6 +28,7 @@
 import org.apache.ignite.internal.configuration.ConfigurationChanger;
 import org.apache.ignite.internal.configuration.ConfigurationChanger.ConfigurationUpdateListener;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
 import org.apache.ignite.internal.configuration.storage.LocalFileConfigurationStorage;
@@ -75,7 +76,7 @@ public static void main(String[] args) {
      * This uses fragments of cluster initialization from {@code IgniteImpl} class to set up local configuration framework.
      */
     private static ConfigurationChanger createConfigurationChanger(Path configPath) {
-        ConfigurationModules modules = ConfigurationModules.create(DefaultsGenerator.class.getClassLoader());
+        ConfigurationModules modules = ConfigurationModulesImpl.create(DefaultsGenerator.class.getClassLoader());
 
         ConfigurationTreeGenerator localConfigurationGenerator = new ConfigurationTreeGenerator(
                 modules.local().rootKeys(),
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/configuration/ItDistributedConfigurationPropertiesTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/configuration/ItDistributedConfigurationPropertiesTest.java
index e52804085a95..37fbb50aa219 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/configuration/ItDistributedConfigurationPropertiesTest.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/configuration/ItDistributedConfigurationPropertiesTest.java
@@ -275,7 +275,7 @@ public synchronized void registerConfigurationListener(ConfigurationStorageListe
             };
 
             generator = new ConfigurationTreeGenerator(DistributedConfiguration.KEY);
-            distributedConfigRegistry = new ConfigurationRegistry(
+            distributedConfigRegistry = new ConfigurationRegistryImpl(
                     List.of(DistributedConfiguration.KEY),
                     distributedCfgStorage,
                     generator,
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/ItIgniteNodeRestartTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/ItIgniteNodeRestartTest.java
index 765c25f61ac5..f77fb3f11fb7 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/ItIgniteNodeRestartTest.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/ItIgniteNodeRestartTest.java
@@ -110,7 +110,7 @@
 import org.apache.ignite.internal.components.LogSyncer;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
-import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfigWriteException;
 import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
@@ -373,7 +373,7 @@ private PartialNode startPartialNode(
                 modules.local().polymorphicSchemaExtensions()
         );
 
-        var nodeConfigRegistry = new ConfigurationRegistry(
+        var nodeConfigRegistry = new ConfigurationRegistryImpl(
                 modules.local().rootKeys(),
                 new LocalFileConfigurationStorage(configFile, localConfigurationGenerator, modules.local()),
                 localConfigurationGenerator,
@@ -549,7 +549,7 @@ public CompletableFuture<Boolean> invoke(Condition condition, List<Operation> su
                 modules.distributed().polymorphicSchemaExtensions()
         );
 
-        var clusterConfigRegistry = new ConfigurationRegistry(
+        var clusterConfigRegistry = new ConfigurationRegistryImpl(
                 modules.distributed().rootKeys(),
                 cfgStorage,
                 distributedConfigurationGenerator,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 39de9eee97b1..5c181caf482e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -17,14 +17,7 @@
 
 package org.apache.ignite.internal.app;
 
-import static java.util.concurrent.TimeUnit.MINUTES;
 import static java.util.stream.Collectors.toSet;
-import static org.apache.ignite.internal.configuration.IgnitePaths.cmgPath;
-import static org.apache.ignite.internal.configuration.IgnitePaths.metastoragePath;
-import static org.apache.ignite.internal.configuration.IgnitePaths.partitionsPath;
-import static org.apache.ignite.internal.configuration.IgnitePaths.vaultPath;
-import static org.apache.ignite.internal.distributionzones.rebalance.RebalanceUtil.pendingPartAssignmentsQueueKey;
-import static org.apache.ignite.internal.distributionzones.rebalance.ZoneRebalanceUtil.zonePartitionStableAssignments;
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_READ;
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_WRITE;
 import static org.apache.ignite.internal.util.CompletableFutures.copyStateTo;
@@ -35,14 +28,11 @@
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 import com.typesafe.config.ConfigRenderOptions;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.inject.qualifiers.Qualifiers;
 import java.nio.file.Path;
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.ServiceLoader;
-import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
@@ -52,105 +42,58 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiPredicate;
-import java.util.function.LongSupplier;
 import java.util.function.Supplier;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteServer;
 import org.apache.ignite.catalog.IgniteCatalog;
-import org.apache.ignite.client.handler.ClientHandlerMetricSource;
 import org.apache.ignite.client.handler.ClientHandlerModule;
 import org.apache.ignite.client.handler.ClientInboundMessageHandler;
 import org.apache.ignite.client.handler.ClusterInfo;
-import org.apache.ignite.client.handler.configuration.ClientConnectorConfiguration;
-import org.apache.ignite.client.handler.configuration.ClientConnectorExtensionConfiguration;
 import org.apache.ignite.compute.IgniteCompute;
-import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
+import org.apache.ignite.internal.app.di.PostConstructionWiring;
 import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
-import org.apache.ignite.internal.catalog.DataNodesAwarePartitionCountCalculator;
 import org.apache.ignite.internal.catalog.PartitionCountCalculator;
 import org.apache.ignite.internal.catalog.PartitionCountCalculatorWrapper;
 import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
-import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
-import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
 import org.apache.ignite.internal.catalog.sql.IgniteCatalogSqlImpl;
-import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
 import org.apache.ignite.internal.cluster.management.ClusterInitializer;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.ClusterState;
-import org.apache.ignite.internal.cluster.management.CmgGroupId;
 import org.apache.ignite.internal.cluster.management.InvalidNodeConfigurationException;
-import org.apache.ignite.internal.cluster.management.NodeAttributesCollector;
-import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesExtensionConfiguration;
 import org.apache.ignite.internal.cluster.management.raft.ClusterStateStorage;
-import org.apache.ignite.internal.cluster.management.raft.ClusterStateStorageManager;
-import org.apache.ignite.internal.cluster.management.raft.RocksDbClusterStateStorage;
-import org.apache.ignite.internal.cluster.management.raft.ValidationManager;
-import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
-import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyServiceImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
-import org.apache.ignite.internal.components.LogSyncer;
-import org.apache.ignite.internal.components.LongJvmPauseDetector;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.NodeProperties;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.AntiHijackIgniteCompute;
 import org.apache.ignite.internal.compute.ComputeComponentImpl;
-import org.apache.ignite.internal.compute.IgniteComputeImpl;
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
-import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
-import org.apache.ignite.internal.compute.configuration.ComputeExtensionConfiguration;
-import org.apache.ignite.internal.compute.executor.ComputeExecutorImpl;
-import org.apache.ignite.internal.compute.state.InMemoryComputeStateMachine;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
-import org.apache.ignite.internal.configuration.ConfigurationDynamicDefaultsPatcherImpl;
-import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
-import org.apache.ignite.internal.configuration.JdbcPortProviderImpl;
-import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
-import org.apache.ignite.internal.configuration.SuggestionsClusterExtensionConfiguration;
-import org.apache.ignite.internal.configuration.SuggestionsConfiguration;
-import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
-import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
-import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
-import org.apache.ignite.internal.configuration.SystemLocalExtensionConfiguration;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.hocon.HoconConverter;
 import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
-import org.apache.ignite.internal.configuration.storage.LocalFileConfigurationStorage;
 import org.apache.ignite.internal.configuration.tree.ConfigurationSource;
-import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
-import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
 import org.apache.ignite.internal.deployunit.DeploymentManagerImpl;
 import org.apache.ignite.internal.deployunit.IgniteDeployment;
-import org.apache.ignite.internal.deployunit.configuration.DeploymentExtensionConfiguration;
-import org.apache.ignite.internal.deployunit.loader.UnitsClassLoaderFactory;
-import org.apache.ignite.internal.deployunit.loader.UnitsContextManager;
-import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
+import org.apache.ignite.internal.di.IgniteComponentLifecycleManager;
+import org.apache.ignite.internal.di.IgniteDiContext;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
-import org.apache.ignite.internal.disaster.system.MetastorageRepairImpl;
 import org.apache.ignite.internal.disaster.system.ServerRestarter;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManager;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManagerImpl;
-import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
-import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
-import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
-import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
-import org.apache.ignite.internal.hlc.ClockWaiter;
 import org.apache.ignite.internal.hlc.HybridClock;
-import org.apache.ignite.internal.hlc.HybridClockImpl;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
-import org.apache.ignite.internal.index.IndexBuildingManager;
-import org.apache.ignite.internal.index.IndexManager;
-import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.lang.IgniteStringBuilder;
 import org.apache.ignite.internal.lang.NodeStoppingException;
@@ -159,67 +102,24 @@
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
-import org.apache.ignite.internal.metastorage.cache.IdempotentCacheVacuumizer;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageCompactionTrigger;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageRevisionListenerRegistry;
-import org.apache.ignite.internal.metastorage.server.ReadOperationForCompactionTracker;
-import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
-import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.metrics.MetricManagerImpl;
-import org.apache.ignite.internal.metrics.configuration.MetricExtensionConfiguration;
-import org.apache.ignite.internal.metrics.logstorage.LogStorageMetrics;
 import org.apache.ignite.internal.metrics.messaging.MetricMessaging;
-import org.apache.ignite.internal.metrics.sources.ClockServiceMetricSource;
-import org.apache.ignite.internal.metrics.sources.JvmMetricSource;
-import org.apache.ignite.internal.metrics.sources.OsMetricSource;
 import org.apache.ignite.internal.network.ChannelType;
-import org.apache.ignite.internal.network.ChannelTypeRegistryProvider;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.DefaultMessagingService;
 import org.apache.ignite.internal.network.IgniteClusterImpl;
 import org.apache.ignite.internal.network.InternalClusterNode;
-import org.apache.ignite.internal.network.LogicalTopologyEventsListener;
-import org.apache.ignite.internal.network.MessageSerializationRegistryImpl;
-import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.NettyBootstrapFactory;
-import org.apache.ignite.internal.network.NettyWorkersRegistrar;
 import org.apache.ignite.internal.network.NetworkMessage;
 import org.apache.ignite.internal.network.PublicApiThreadingIgniteCluster;
-import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
-import org.apache.ignite.internal.network.configuration.NetworkExtensionConfiguration;
-import org.apache.ignite.internal.network.recovery.InMemoryStaleIds;
-import org.apache.ignite.internal.network.scalecube.ScaleCubeClusterService;
-import org.apache.ignite.internal.network.serialization.MessageSerializationRegistry;
-import org.apache.ignite.internal.network.serialization.SerializationRegistryServiceLoader;
-import org.apache.ignite.internal.network.wrapper.JumpToExecutorByConsistentIdAfterSend;
 import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
-import org.apache.ignite.internal.partition.replicator.network.PartitionReplicationMessageGroup;
-import org.apache.ignite.internal.partition.replicator.raft.snapshot.outgoing.OutgoingSnapshotsManager;
-import org.apache.ignite.internal.partition.replicator.schema.CatalogValidationSchemasSource;
-import org.apache.ignite.internal.partition.replicator.schema.ValidationSchemasSource;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
 import org.apache.ignite.internal.raft.Loza;
-import org.apache.ignite.internal.raft.Marshaller;
-import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
-import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
-import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
-import org.apache.ignite.internal.raft.configuration.RaftExtensionConfiguration;
-import org.apache.ignite.internal.raft.server.impl.GroupStoragesContextResolver;
-import org.apache.ignite.internal.raft.storage.GroupStoragesDestructionIntents;
 import org.apache.ignite.internal.raft.storage.LogStorageManager;
-import org.apache.ignite.internal.raft.storage.impl.VaultGroupStoragesDestructionIntents;
-import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
-import org.apache.ignite.internal.raft.util.SharedLogStorageManagerUtils;
-import org.apache.ignite.internal.replicator.PartitionGroupId;
 import org.apache.ignite.internal.replicator.ReplicaManager;
-import org.apache.ignite.internal.replicator.ReplicaService;
-import org.apache.ignite.internal.replicator.TablePartitionId;
-import org.apache.ignite.internal.replicator.VersionedAssignments;
-import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
-import org.apache.ignite.internal.replicator.configuration.ReplicationExtensionConfiguration;
 import org.apache.ignite.internal.rest.RestComponent;
 import org.apache.ignite.internal.rest.RestFactory;
 import org.apache.ignite.internal.rest.RestManager;
@@ -234,77 +134,38 @@
 import org.apache.ignite.internal.rest.deployment.CodeDeploymentRestFactory;
 import org.apache.ignite.internal.rest.events.RestEventsFactory;
 import org.apache.ignite.internal.rest.metrics.MetricRestFactory;
+import org.apache.ignite.internal.rest.node.JdbcPortProvider;
 import org.apache.ignite.internal.rest.node.NodeManagementRestFactory;
 import org.apache.ignite.internal.rest.node.NodePropertiesFactory;
 import org.apache.ignite.internal.rest.recovery.DisasterRecoveryFactory;
 import org.apache.ignite.internal.rest.recovery.system.SystemDisasterRecoveryFactory;
 import org.apache.ignite.internal.rest.sql.SqlQueryRestFactory;
-import org.apache.ignite.internal.schema.SchemaManager;
 import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
-import org.apache.ignite.internal.schema.SchemaSyncService;
-import org.apache.ignite.internal.schema.configuration.GcConfiguration;
-import org.apache.ignite.internal.schema.configuration.GcExtensionConfiguration;
 import org.apache.ignite.internal.security.authentication.AuthenticationManager;
-import org.apache.ignite.internal.security.authentication.AuthenticationManagerImpl;
-import org.apache.ignite.internal.security.configuration.SecurityConfiguration;
-import org.apache.ignite.internal.security.configuration.SecurityExtensionConfiguration;
 import org.apache.ignite.internal.sql.api.IgniteSqlImpl;
 import org.apache.ignite.internal.sql.api.PublicApiThreadingIgniteSql;
-import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
-import org.apache.ignite.internal.sql.configuration.local.SqlNodeExtensionConfiguration;
 import org.apache.ignite.internal.sql.engine.QueryProcessor;
 import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
-import org.apache.ignite.internal.sql.engine.api.kill.CancellableOperationType;
-import org.apache.ignite.internal.sql.engine.api.kill.OperationKillHandler;
 import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
 import org.apache.ignite.internal.storage.DataStorageManager;
-import org.apache.ignite.internal.storage.DataStorageModule;
-import org.apache.ignite.internal.storage.DataStorageModules;
-import org.apache.ignite.internal.storage.configurations.StorageExtensionConfiguration;
-import org.apache.ignite.internal.storage.engine.StorageEngine;
-import org.apache.ignite.internal.storage.engine.ThreadAssertingStorageEngine;
-import org.apache.ignite.internal.system.CpuInformationProvider;
-import org.apache.ignite.internal.system.JvmCpuInformationProvider;
 import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
 import org.apache.ignite.internal.systemview.api.SystemViewManager;
-import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
 import org.apache.ignite.internal.table.distributed.PublicApiThreadingIgniteTables;
 import org.apache.ignite.internal.table.distributed.TableManager;
 import org.apache.ignite.internal.table.distributed.disaster.DisasterRecoveryManager;
-import org.apache.ignite.internal.table.distributed.index.IndexMetaStorage;
-import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorServiceImpl;
-import org.apache.ignite.internal.table.distributed.raft.PartitionSafeTimeValidator;
-import org.apache.ignite.internal.table.distributed.schema.CheckCatalogVersionOnActionRequest;
-import org.apache.ignite.internal.table.distributed.schema.CheckCatalogVersionOnAppendEntries;
-import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
-import org.apache.ignite.internal.table.distributed.schema.ThreadLocalPartitionCommandsMarshaller;
 import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.threading.PublicApiThreadingIgniteCatalog;
-import org.apache.ignite.internal.tx.LockManager;
 import org.apache.ignite.internal.tx.TxManager;
-import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
-import org.apache.ignite.internal.tx.configuration.TransactionExtensionConfiguration;
-import org.apache.ignite.internal.tx.impl.HeapLockManager;
 import org.apache.ignite.internal.tx.impl.IgniteTransactionsImpl;
 import org.apache.ignite.internal.tx.impl.PublicApiThreadingIgniteTransactions;
 import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
-import org.apache.ignite.internal.tx.impl.ResourceVacuumManager;
-import org.apache.ignite.internal.tx.impl.TransactionIdGenerator;
-import org.apache.ignite.internal.tx.impl.TransactionInflights;
 import org.apache.ignite.internal.tx.impl.TxManagerImpl;
-import org.apache.ignite.internal.tx.impl.VolatileTxStateMetaStorage;
-import org.apache.ignite.internal.tx.message.TxMessageGroup;
 import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
 import org.apache.ignite.internal.vault.VaultManager;
-import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
-import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
-import org.apache.ignite.internal.worker.CriticalWorkerWatchdog;
-import org.apache.ignite.internal.worker.ThreadAssertions;
 import org.apache.ignite.lang.IgniteException;
 import org.apache.ignite.network.IgniteCluster;
 import org.apache.ignite.network.NetworkAddress;
 import org.apache.ignite.network.NodeMetadata;
-import org.apache.ignite.raft.jraft.rpc.impl.RaftGroupEventsClientListener;
 import org.apache.ignite.sql.IgniteSql;
 import org.apache.ignite.table.IgniteTables;
 import org.apache.ignite.tx.IgniteTransactions;
@@ -318,12 +179,6 @@ public class IgniteImpl implements Ignite {
     /** The logger. */
     private static final IgniteLogger LOG = Loggers.forClass(IgniteImpl.class);
 
-    /** Used for durable destruction purposes. */
-    private static final String PARTITION_GROUP_NAME = "partition";
-
-    /** Name of a transaction state directory. */
-    private static final String TX_STATE_DIR = "tx-state";
-
     /** Ignite node name. */
     private final String name;
 
@@ -332,7 +187,11 @@ public class IgniteImpl implements Ignite {
     /** Lifecycle manager. */
     private final LifecycleManager lifecycleManager;
 
-    private final ThreadPoolsManager threadPoolsManager;
+    /** Micronaut DI context for component construction and dependency injection. */
+    private final ApplicationContext diContext;
+
+    /** Lifecycle manager for DI-managed components. */
+    private final IgniteComponentLifecycleManager componentLifecycleManager;
 
     /** Vault manager. */
     private final VaultManager vaultMgr;
@@ -355,34 +214,24 @@ public class IgniteImpl implements Ignite {
 
     private final ComputeComponentImpl computeComponent;
 
-    private final CriticalWorkerWatchdog criticalWorkerRegistry;
-
     /** Failure processor. */
     private final FailureManager failureManager;
 
     /** Netty bootstrap factory. */
     private final NettyBootstrapFactory nettyBootstrapFactory;
 
-    private final NettyWorkersRegistrar nettyWorkersRegistrar;
-
     /** Raft manager. */
     private final Loza raftMgr;
 
     /** Meta storage manager. */
     private final MetaStorageManagerImpl metaStorageMgr;
 
-    /** Metastorage compaction trigger. */
-    private final MetaStorageCompactionTrigger metaStorageCompactionTrigger;
-
     /** Placement driver manager. */
     private final PlacementDriverManager placementDriverMgr;
 
     /** Configuration registry that handles cluster (distributed) configuration. */
     private final ConfigurationRegistry clusterConfigRegistry;
 
-    /** Idempotent cache vacuumizer. */
-    private final IdempotentCacheVacuumizer idempotentCacheVacuumizer;
-
     /** Cluster initializer. */
     private final ClusterInitializer clusterInitializer;
 
@@ -400,8 +249,6 @@ public class IgniteImpl implements Ignite {
     /** Disaster recovery manager. */
     private final DisasterRecoveryManager disasterRecoveryManager;
 
-    private final IndexManager indexManager;
-
     /** Rest module. */
     private final RestComponent restComponent;
 
@@ -415,8 +262,6 @@ public class IgniteImpl implements Ignite {
 
     private final ComponentWorkingDir metastorageWorkDir;
 
-    private final ComponentWorkingDir cmgWorkDir;
-
     /** Client handler module. */
     private final ClientHandlerModule clientHandlerModule;
 
@@ -426,17 +271,8 @@ public class IgniteImpl implements Ignite {
     /** Compute. */
     private final IgniteComputeInternal compute;
 
-    /** JVM pause detector. */
-    private final LongJvmPauseDetector longJvmPauseDetector;
-
-    /** Data storage manager. */
-    private final DataStorageManager dataStorageMgr;
-
     private final SchemaSafeTimeTrackerImpl schemaSafeTimeTracker;
 
-    /** Schema manager. */
-    private final SchemaManager schemaManager;
-
     /** Metric manager. */
     private final MetricManagerImpl metricManager;
 
@@ -449,24 +285,13 @@ public class IgniteImpl implements Ignite {
 
     private final PartitionReplicaLifecycleManager partitionReplicaLifecycleManager;
 
-    /** Creator for volatile {@link LogStorageManager} instances. */
-    private final VolatileLogStorageManagerCreator volatileLogStorageManagerCreator;
-
-    private final LogStorageMetrics logStorageMetrics;
-
-    private final SystemPropertiesComponent systemPropertiesComponent;
-
     /** A hybrid logical clock. */
     private final HybridClock clock;
 
-    private final ClockWaiter clockWaiter;
-
     private final ClockService clockService;
 
     private final LowWatermarkImpl lowWatermark;
 
-    private final OutgoingSnapshotsManager outgoingSnapshotsManager;
-
     private final CatalogManager catalogManager;
 
     private final CatalogCompactionRunner catalogCompactionRunner;
@@ -474,20 +299,11 @@ public class IgniteImpl implements Ignite {
     private final AuthenticationManager authenticationManager;
 
     /** Timestamp tracker for embedded transactions. */
-    private final HybridTimestampTracker observableTimestampTracker = HybridTimestampTracker.atomicTracker(null);
+    private final HybridTimestampTracker observableTimestampTracker;
 
     /** System views manager. */
     private final SystemViewManagerImpl systemViewManager;
 
-    /** Index building manager. */
-    private final IndexBuildingManager indexBuildingManager;
-
-    /** Local node RW transaction completion checker for indexes. */
-    private final IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker;
-
-    /** Cleanup manager for tx resources. */
-    private final ResourceVacuumManager resourceVacuumManager;
-
     /** Remote triggered resources registry. */
     private final RemotelyTriggeredResourceRegistry resourcesRegistry;
 
@@ -503,14 +319,6 @@ public class IgniteImpl implements Ignite {
     /** Partitions log storage manager for raft. */
     private final LogStorageManager partitionsLogStorageManager;
 
-    private final LogStorageManager msLogStorageManager;
-
-    private final LogStorageManager cmgLogStorageManager;
-
-    private final RaftGroupOptionsConfigurer partitionRaftConfigurer;
-
-    private final IndexMetaStorage indexMetaStorage;
-
     private final EventLogImpl eventLog;
 
     private final KillCommandHandler killCommandHandler;
@@ -522,12 +330,12 @@ public class IgniteImpl implements Ignite {
     @Nullable
     private volatile ClusterState clusterState;
 
-    private final ClockServiceMetricSource clockServiceMetricSource;
-
-    private final PartitionModificationCounterFactory partitionModificationCounterFactory;
-
     private final PartitionCountCalculatorWrapper partitionCountCalculatorWrapper;
 
+    /** Data storage manager, kept as a field for reflective access by compatibility tests (CheckpointJob). */
+    @SuppressWarnings("unused")
+    private final DataStorageManager dataStorageMgr;
+
     /** Future that completes when the node has joined the cluster. */
     private final CompletableFuture<Ignite> joinFuture = new CompletableFuture<>();
 
@@ -552,46 +360,25 @@ public class IgniteImpl implements Ignite {
         this.name = node.name();
         this.workDir = workDir;
 
-        longJvmPauseDetector = new LongJvmPauseDetector(name);
-
         lifecycleManager = new LifecycleManager(name);
 
-        metricManager = new MetricManagerImpl(name, () -> clusterState().clusterTag().clusterId());
-
-        threadPoolsManager = new ThreadPoolsManager(name, metricManager);
-
-        vaultMgr = new VaultManager(new PersistentVaultService(vaultPath(workDir)));
-
-        nodeProperties = new NodePropertiesImpl(vaultMgr);
-
-        CpuInformationProvider cpuInformationProvider = new JvmCpuInformationProvider();
-
-        ConfigurationModules modules = ConfigurationModules.create(serviceProviderClassLoader);
-
-        ConfigurationTreeGenerator localConfigurationGenerator = new ConfigurationTreeGenerator(
-                modules.local().rootKeys(),
-                modules.local().schemaExtensions(),
-                modules.local().polymorphicSchemaExtensions()
-        );
+        // Build the Micronaut DI context with seed singletons.
+        Supplier<UUID> clusterIdSupplier = () -> clusterState().clusterTag().clusterId();
 
-        LocalFileConfigurationStorage localFileConfigurationStorage = new LocalFileConfigurationStorage(
-                name,
-                configPath,
-                localConfigurationGenerator,
-                modules.local()
-        );
+        NodeIdentity nodeIdentity = new NodeIdentity(name, workDir, configPath, serviceProviderClassLoader, clusterIdSupplier);
 
-        ConfigurationValidator localConfigurationValidator =
-                ConfigurationValidatorImpl.withDefaultValidators(localConfigurationGenerator, modules.local().validators());
+        diContext = IgniteDiContext.builder()
+                .withSingleton(nodeIdentity)
+                .withSingleton(node)
+                .withSingleton(restarter)
+                .withSingleton(this)
+                .withPackages("org.apache.ignite.internal")
+                .withExcludedPackages("org.apache.ignite.internal.rest", "org.apache.ignite.internal.cli")
+                .build();
 
-        nodeConfigRegistry = ConfigurationRegistry.create(
-                modules.local(),
-                localFileConfigurationStorage,
-                localConfigurationGenerator,
-                localConfigurationValidator
-        );
+        // Start local configuration early — factory methods read config values during bean construction.
+        nodeConfigRegistry = diContext.getBean(ConfigurationRegistry.class, Qualifiers.byName("nodeConfig"));
 
-        // Start local configuration to be able to read all local properties.
         try {
             lifecycleManager.startComponentsAsync(new ComponentContext(), nodeConfigRegistry);
         } catch (NodeStoppingException e) {
@@ -599,752 +386,84 @@ public class IgniteImpl implements Ignite {
         }
 
         LOG.info("Starting node: [name={}, workDir={}, configPath={}]", name, workDir, configPath);
-
         LOG.info("Local node configuration: {}", convertToHoconString(nodeConfigRegistry));
 
-        NetworkConfiguration networkConfiguration = nodeConfigRegistry.getConfiguration(NetworkExtensionConfiguration.KEY).network();
-
-        MessageSerializationRegistry serializationRegistry = createSerializationRegistry(serviceProviderClassLoader);
-
-        FailureProcessorConfiguration failureProcessorConfiguration = nodeConfigRegistry.getConfiguration(
-                FailureProcessorExtensionConfiguration.KEY).failureHandler();
-        failureManager = new FailureManager(name, node::shutdown, failureProcessorConfiguration);
-
-        SystemLocalConfiguration systemConfiguration = nodeConfigRegistry.getConfiguration(SystemLocalExtensionConfiguration.KEY).system();
-
-        cmgWorkDir = cmgPath(systemConfiguration, workDir);
-
-        // TODO: IGNITE-16841 - use common RocksDB instance to store cluster state as well.
-        clusterStateStorage = new RocksDbClusterStateStorage(cmgWorkDir.dbPath(), name);
-
-        clusterIdService = new ClusterIdService(vaultMgr);
-
-        criticalWorkerRegistry = new CriticalWorkerWatchdog(
-                systemConfiguration.criticalWorkers(),
-                threadPoolsManager.commonScheduler(),
-                failureManager
-        );
-
-        nettyBootstrapFactory = new NettyBootstrapFactory(networkConfiguration, name);
-        nettyWorkersRegistrar = new NettyWorkersRegistrar(
-                criticalWorkerRegistry,
-                threadPoolsManager.commonScheduler(),
-                nettyBootstrapFactory,
-                systemConfiguration.criticalWorkers(),
-                failureManager
-        );
-
-        clusterSvc = new ScaleCubeClusterService(
-                name,
-                networkConfiguration,
-                nettyBootstrapFactory,
-                serializationRegistry,
-                new InMemoryStaleIds(),
-                clusterIdService,
-                criticalWorkerRegistry,
-                failureManager,
-                ChannelTypeRegistryProvider.loadByServiceLoader(serviceProviderClassLoader),
-                new DefaultIgniteProductVersionSource(),
-                metricManager
-        );
-
-        clock = new HybridClockImpl(failureManager);
-
-        clockWaiter = new ClockWaiter(name, clock, threadPoolsManager.commonScheduler());
-
-        RaftConfiguration raftConfiguration = nodeConfigRegistry.getConfiguration(RaftExtensionConfiguration.KEY).raft();
-
-        // TODO https://issues.apache.org/jira/browse/IGNITE-19051
-        RaftGroupEventsClientListener raftGroupEventsClientListener = new RaftGroupEventsClientListener();
-
-        partitionsWorkDir = partitionsPath(systemConfiguration, workDir);
-
-        partitionsLogStorageManager = SharedLogStorageManagerUtils.create(
-                "table data log",
-                clusterSvc.nodeName(),
-                partitionsWorkDir.raftLogPath(),
-                raftConfiguration.fsync().value()
-        );
-
-        LogSyncer partitionsLogSyncer = partitionsLogStorageManager.logSyncer();
-
-        metastorageWorkDir = metastoragePath(systemConfiguration, workDir);
-
-        msLogStorageManager = SharedLogStorageManagerUtils.create(
-                "meta-storage log",
-                clusterSvc.nodeName(),
-                metastorageWorkDir.raftLogPath(),
-                // If it changes, then it will be necessary to set LogSyncer to RocksDbKeyValueStorage.
-                true
-        );
-
-        cmgLogStorageManager = SharedLogStorageManagerUtils.create(
-                "cluster-management-group log",
-                clusterSvc.nodeName(),
-                cmgWorkDir.raftLogPath(),
-                true
-        );
-
-        RaftGroupOptionsConfigurer cmgRaftConfigurer =
-                RaftGroupOptionsConfigHelper.configureProperties(cmgLogStorageManager, cmgWorkDir.metaPath());
-
-        RaftGroupOptionsConfigurer msRaftConfigurer =
-                RaftGroupOptionsConfigHelper.configureProperties(msLogStorageManager, metastorageWorkDir.metaPath());
-
-        partitionRaftConfigurer =
-                RaftGroupOptionsConfigHelper.configureProperties(partitionsLogStorageManager, partitionsWorkDir.metaPath());
-
-        GroupStoragesContextResolver groupStoragesContextResolver = createGroupStoragesContextResolver();
-
-        GroupStoragesDestructionIntents groupStoragesDestructionIntents = new VaultGroupStoragesDestructionIntents(vaultMgr);
-
-        raftMgr = new Loza(
-                clusterSvc,
-                metricManager,
-                raftConfiguration,
-                systemConfiguration,
-                clock,
-                raftGroupEventsClientListener,
-                failureManager,
-                groupStoragesDestructionIntents,
-                groupStoragesContextResolver
-        );
-
-        MessagingService messagingServiceReturningToStorageOperationsPool = new JumpToExecutorByConsistentIdAfterSend(
-                clusterSvc.messagingService(),
-                name,
-                message -> threadPoolsManager.partitionOperationsExecutor()
-        );
-
-        var logicalTopology = new LogicalTopologyImpl(clusterStateStorage, failureManager);
-        logicalTopology.addEventListener(logicalTopologyJoinedNodesListener(clusterSvc.topologyService()));
-
-        ConfigurationTreeGenerator distributedConfigurationGenerator = new ConfigurationTreeGenerator(
-                modules.distributed().rootKeys(),
-                modules.distributed().schemaExtensions(),
-                modules.distributed().polymorphicSchemaExtensions()
-        );
-
-        ConfigurationValidator distributedCfgValidator = ConfigurationValidatorImpl.withDefaultValidators(
-                distributedConfigurationGenerator,
-                modules.distributed().validators()
-        );
-
-        ConfigurationDynamicDefaultsPatcher clusterCfgDynamicDefaultsPatcher = new ConfigurationDynamicDefaultsPatcherImpl(
-                modules.distributed(),
-                distributedConfigurationGenerator
-        );
-
-        clusterInitializer = new ClusterInitializer(
-                clusterSvc,
-                clusterCfgDynamicDefaultsPatcher,
-                distributedCfgValidator
-        );
-
-        NodeAttributesCollector nodeAttributesCollector =
-                new NodeAttributesCollector(
-                        nodeConfigRegistry.getConfiguration(NodeAttributesExtensionConfiguration.KEY).nodeAttributes(),
-                        nodeConfigRegistry.getConfiguration(StorageExtensionConfiguration.KEY).storage()
-                );
-
-        nodeAttributesCollector.register(nodeProperties);
-
-        var clusterStateStorageMgr =  new ClusterStateStorageManager(clusterStateStorage);
-        var validationManager = new ValidationManager(clusterStateStorageMgr, logicalTopology);
-
-        SystemDisasterRecoveryStorage systemDisasterRecoveryStorage = new SystemDisasterRecoveryStorage(vaultMgr);
-        cmgMgr = new ClusterManagementGroupManager(
-                vaultMgr,
-                systemDisasterRecoveryStorage,
-                clusterSvc,
-                clusterInitializer,
-                raftMgr,
-                clusterStateStorageMgr,
-                logicalTopology,
-                validationManager,
-                nodeAttributesCollector,
-                failureManager,
-                clusterIdService,
-                cmgRaftConfigurer,
-                metricManager
-        );
-
-        logicalTopologyService = new LogicalTopologyServiceImpl(logicalTopology, cmgMgr);
-
-        var topologyAwareRaftGroupServiceFactory = new TopologyAwareRaftGroupServiceFactory(
-                clusterSvc,
-                logicalTopologyService,
-                Loza.FACTORY,
-                raftGroupEventsClientListener
-        );
-
-        var readOperationForCompactionTracker = new ReadOperationForCompactionTracker();
-
-        var storage = new RocksDbKeyValueStorage(
-                name,
-                metastorageWorkDir.dbPath(),
-                failureManager,
-                readOperationForCompactionTracker,
-                threadPoolsManager.commonScheduler()
-        );
-
-        metaStorageMgr = new MetaStorageManagerImpl(
-                clusterSvc,
-                cmgMgr,
-                logicalTopologyService,
-                raftMgr,
-                storage,
-                clock,
-                topologyAwareRaftGroupServiceFactory,
-                metricManager,
-                systemDisasterRecoveryStorage,
-                new MetastorageRepairImpl(clusterSvc.messagingService(), logicalTopology, cmgMgr),
-                msRaftConfigurer,
-                readOperationForCompactionTracker,
-                threadPoolsManager.tableIoExecutor(),
-                failureManager
-        );
-
-        cfgStorage = new DistributedConfigurationStorage(name, metaStorageMgr);
-
-        clusterConfigRegistry = ConfigurationRegistry.create(
-                modules.distributed(),
-                cfgStorage,
-                distributedConfigurationGenerator,
-                distributedCfgValidator
-        );
-
-        metricManager.configure(clusterConfigRegistry.getConfiguration(MetricExtensionConfiguration.KEY).metrics());
-
-        eventLog = new EventLogImpl(
-                clusterConfigRegistry.getConfiguration(EventLogExtensionConfiguration.KEY).eventlog(),
-                () -> clusterState().clusterTag().clusterId(),
-                name
-        );
-
-        SystemDistributedConfiguration systemDistributedConfiguration =
-                clusterConfigRegistry.getConfiguration(SystemDistributedExtensionConfiguration.KEY).system();
-
-        metaStorageMgr.configure(systemDistributedConfiguration);
-
-        systemDisasterRecoveryManager = new SystemDisasterRecoveryManagerImpl(
-                name,
-                clusterSvc.topologyService(),
-                clusterSvc.messagingService(),
-                vaultMgr,
-                restarter,
-                metaStorageMgr,
-                cmgMgr,
-                clusterIdService
-        );
-
-        metaStorageCompactionTrigger = new MetaStorageCompactionTrigger(
-                name,
-                storage,
-                metaStorageMgr,
-                failureManager,
-                readOperationForCompactionTracker,
-                systemDistributedConfiguration
-        );
-
-        SchemaSynchronizationConfiguration schemaSyncConfig = clusterConfigRegistry
-                .getConfiguration(SchemaSynchronizationExtensionConfiguration.KEY).schemaSync();
-
-        clockServiceMetricSource = new ClockServiceMetricSource();
-
-        clockService = new ClockServiceImpl(
-                clock,
-                clockWaiter,
-                () -> schemaSyncConfig.maxClockSkewMillis().value(),
-                clockServiceMetricSource::onMaxClockSkewExceeded
-        );
-
-        idempotentCacheVacuumizer = new IdempotentCacheVacuumizer(
-                name,
-                threadPoolsManager.commonScheduler(),
-                metaStorageMgr::evictIdempotentCommandsCache,
-                raftConfiguration.retryTimeoutMillis(),
-                clockService,
-                failureManager,
-                1,
-                1,
-                MINUTES
-        );
-
-        metaStorageMgr.addElectionListener(idempotentCacheVacuumizer);
-
-        var registry = new MetaStorageRevisionListenerRegistry(metaStorageMgr);
-
-        LongSupplier delayDurationMsSupplier = delayDurationMsSupplier(schemaSyncConfig);
-
-        partitionCountCalculatorWrapper = new PartitionCountCalculatorWrapper();
-
-        CatalogManagerImpl catalogManager = new CatalogManagerImpl(
-                new UpdateLogImpl(metaStorageMgr, failureManager),
-                clockService,
-                failureManager,
-                delayDurationMsSupplier,
-                partitionCountCalculatorWrapper
-        );
-
-        ReplicationConfiguration replicationConfig = clusterConfigRegistry
-                .getConfiguration(ReplicationExtensionConfiguration.KEY).replication();
-
-        placementDriverMgr = new PlacementDriverManager(
-                name,
-                metaStorageMgr,
-                MetastorageGroupId.INSTANCE,
-                clusterSvc,
-                cmgMgr::metaStorageNodes,
-                logicalTopologyService,
-                raftMgr,
-                topologyAwareRaftGroupServiceFactory,
-                clockService,
-                failureManager,
-                replicationConfig,
-                threadPoolsManager.commonScheduler(),
-                metricManager,
-                zoneId -> distributionZoneManager().currentDataNodes(zoneId)
-        );
-
-        TransactionConfiguration txConfig = clusterConfigRegistry.getConfiguration(TransactionExtensionConfiguration.KEY).transaction();
-
-        ReplicaService replicaSvc = new ReplicaService(
-                messagingServiceReturningToStorageOperationsPool,
-                clockService,
-                threadPoolsManager.partitionOperationsExecutor(),
-                replicationConfig,
-                threadPoolsManager.commonScheduler()
-        );
-
-        LongSupplier partitionIdleSafeTimePropagationPeriodMsSupplier = partitionIdleSafeTimePropagationPeriodMsSupplier(replicationConfig);
-
-        // TODO: IGNITE-22222 this instantiation should be moved inside ReplicaManager's constructor
-        Marshaller raftMarshaller = new ThreadLocalPartitionCommandsMarshaller(clusterSvc.serializationRegistry());
-
-        volatileLogStorageManagerCreator = new VolatileLogStorageManagerCreator(name, workDir.resolve("volatile-log-spillout"));
-
-        logStorageMetrics = new LogStorageMetrics(
-                name,
-                metricManager,
-                cmgLogStorageManager,
-                msLogStorageManager,
-                partitionsLogStorageManager,
-                volatileLogStorageManagerCreator
-        );
-
-        schemaSafeTimeTracker = new SchemaSafeTimeTrackerImpl(metaStorageMgr.clusterTime());
-        metaStorageMgr.registerNotificationEnqueuedListener(schemaSafeTimeTracker);
-
-        SchemaSyncService schemaSyncService = new SchemaSyncServiceImpl(schemaSafeTimeTracker, delayDurationMsSupplier);
-
-        schemaManager = new SchemaManager(registry, catalogManager);
-
-        ValidationSchemasSource validationSchemasSource = new CatalogValidationSchemasSource(catalogManager, schemaManager);
-
-        replicaMgr = new ReplicaManager(
-                name,
-                clusterSvc,
-                cmgMgr,
-                groupId -> zonePartitionStableAssignments(metaStorageMgr, groupId),
-                clockService,
-                Set.of(PartitionReplicationMessageGroup.class, TxMessageGroup.class),
-                placementDriverMgr.placementDriver(),
-                threadPoolsManager.partitionOperationsExecutor(),
-                partitionIdleSafeTimePropagationPeriodMsSupplier,
-                failureManager,
-                raftMarshaller,
-                new PartitionSafeTimeValidator(validationSchemasSource, catalogManager, schemaSyncService),
-                topologyAwareRaftGroupServiceFactory,
-                raftMgr,
-                partitionRaftConfigurer,
-                volatileLogStorageManagerCreator,
-                threadPoolsManager.tableIoExecutor(),
-                replicaGrpId -> metaStorageMgr.get(pendingPartAssignmentsQueueKey((TablePartitionId) replicaGrpId))
-                        .thenApply(entry -> new VersionedAssignments(entry.value(), entry.revision())),
-                threadPoolsManager.commonScheduler()
-        );
-
-        DataStorageModules dataStorageModules = new DataStorageModules(
-                ServiceLoader.load(DataStorageModule.class, serviceProviderClassLoader)
-        );
-
-        Path storagePath = partitionsWorkDir.dbPath();
-
-        GcConfiguration gcConfig = clusterConfigRegistry.getConfiguration(GcExtensionConfiguration.KEY).gc();
-
-        Map<String, StorageEngine> storageEngines = dataStorageModules.createStorageEngines(
-                name,
-                metricManager,
-                nodeConfigRegistry,
-                storagePath,
-                longJvmPauseDetector,
-                failureManager,
-                partitionsLogSyncer,
-                clock,
-                threadPoolsManager.commonScheduler()
-        );
-
-        dataStorageMgr = new DataStorageManager(
-                applyThreadAssertionsIfNeeded(storageEngines),
-                nodeConfigRegistry.getConfiguration(StorageExtensionConfiguration.KEY).storage()
-        );
-
-        outgoingSnapshotsManager = new OutgoingSnapshotsManager(name, clusterSvc.messagingService(), failureManager);
-
-        systemViewManager = new SystemViewManagerImpl(name, catalogManager, failureManager);
-        nodeAttributesCollector.register(systemViewManager);
-        logicalTopology.addEventListener(systemViewManager);
-        systemViewManager.register(catalogManager);
-
-        this.catalogManager = catalogManager;
-
-        lowWatermark = new LowWatermarkImpl(
-                name,
-                gcConfig.lowWatermark(),
-                clockService,
-                vaultMgr,
-                failureManager,
-                clusterSvc.messagingService()
-        );
-
-        this.indexMetaStorage = new IndexMetaStorage(catalogManager, lowWatermark, metaStorageMgr);
-
-        raftMgr.appendEntriesRequestInterceptor(new CheckCatalogVersionOnAppendEntries(catalogManager));
-        raftMgr.actionRequestInterceptor(new CheckCatalogVersionOnActionRequest(catalogManager));
-
-        distributionZoneManager = new DistributionZoneManager(
-                name,
-                () -> clusterSvc.topologyService().localMember().id(),
-                metaStorageMgr,
-                logicalTopologyService,
-                failureManager,
-                catalogManager,
-                systemDistributedConfiguration,
-                clockService,
-                metricManager,
-                lowWatermark
-        );
-
-        var dataNodesAwarePartitionCountCalculator = new DataNodesAwarePartitionCountCalculator(
-                distributionZoneManager::estimatedDataNodesCount,
-                cpuInformationProvider
-        );
-
-        partitionCountCalculatorWrapper.setPartitionCountCalculator(dataNodesAwarePartitionCountCalculator);
-
-        indexNodeFinishedRwTransactionsChecker = new IndexNodeFinishedRwTransactionsChecker(
-                catalogManager,
-                clusterSvc.messagingService(),
-                clock
-        );
-
-        MinimumRequiredTimeCollectorServiceImpl minTimeCollectorService = new MinimumRequiredTimeCollectorServiceImpl();
-
-        CatalogCompactionRunner catalogCompactionRunner = new CatalogCompactionRunner(
-                name,
-                catalogManager,
-                clusterSvc.messagingService(),
-                logicalTopologyService,
-                placementDriverMgr.placementDriver(),
-                replicaSvc,
-                clockService,
-                schemaSyncService,
-                clusterSvc.topologyService(),
-                lowWatermark,
-                indexNodeFinishedRwTransactionsChecker,
-                minTimeCollectorService,
-                new RebalanceMinimumRequiredTimeProviderImpl(metaStorageMgr, catalogManager)
-        );
-
-        metaStorageMgr.addElectionListener(catalogCompactionRunner::updateCoordinator);
-        this.catalogCompactionRunner = catalogCompactionRunner;
-
-        killCommandHandler = new KillCommandHandler(name, logicalTopologyService, clusterSvc.messagingService());
-
-        resourcesRegistry = new RemotelyTriggeredResourceRegistry();
-
-        VolatileTxStateMetaStorage txStateVolatileStorage = new VolatileTxStateMetaStorage();
-
-        TransactionInflights transactionInflights =
-                new TransactionInflights(placementDriverMgr.placementDriver(), clockService, txStateVolatileStorage);
-
-        LockManager lockMgr = new HeapLockManager(systemConfiguration, txStateVolatileStorage);
-
-        // TODO: IGNITE-19344 - use nodeId that is validated on join (and probably generated differently).
-        txManager = new TxManagerImpl(
-                name,
-                txConfig,
-                systemDistributedConfiguration,
-                messagingServiceReturningToStorageOperationsPool,
-                clusterSvc.topologyService(),
-                replicaSvc,
-                lockMgr,
-                txStateVolatileStorage,
-                clockService,
-                new TransactionIdGenerator(() -> clusterSvc.nodeName().hashCode()),
-                placementDriverMgr.placementDriver(),
-                partitionIdleSafeTimePropagationPeriodMsSupplier,
-                indexNodeFinishedRwTransactionsChecker,
-                threadPoolsManager.partitionOperationsExecutor(),
-                resourcesRegistry,
-                transactionInflights,
-                lowWatermark,
-                threadPoolsManager.commonScheduler(),
-                failureManager,
-                metricManager
-        );
-
-        sharedTxStateStorage = new TxStateRocksDbSharedStorage(
-                name,
-                storagePath.resolve(TX_STATE_DIR),
-                threadPoolsManager.commonScheduler(),
-                threadPoolsManager.tableIoExecutor(),
-                partitionsLogSyncer,
-                failureManager
-        );
-
-        partitionReplicaLifecycleManager = new PartitionReplicaLifecycleManager(
-                catalogManager,
-                replicaMgr,
-                distributionZoneManager,
-                metaStorageMgr,
-                clusterSvc.topologyService(),
-                lowWatermark,
-                failureManager,
-                threadPoolsManager.tableIoExecutor(),
-                threadPoolsManager.rebalanceScheduler(),
-                threadPoolsManager.partitionOperationsExecutor(),
-                clockService,
-                placementDriverMgr.placementDriver(),
-                schemaSyncService,
-                systemDistributedConfiguration,
-                sharedTxStateStorage,
-                txManager,
-                schemaManager,
-                dataStorageMgr,
-                outgoingSnapshotsManager,
-                metricManager,
-                messagingServiceReturningToStorageOperationsPool,
-                replicaSvc
-        );
-
-        systemViewManager.register(txManager);
-        killCommandHandler.register(transactionKillHandler(txManager));
-
-        resourceVacuumManager = new ResourceVacuumManager(
-                name,
-                resourcesRegistry,
-                clusterSvc.topologyService(),
-                messagingServiceReturningToStorageOperationsPool,
-                transactionInflights,
-                txManager,
-                lowWatermark,
-                failureManager,
-                metricManager
-        );
-
-        partitionModificationCounterFactory = new PartitionModificationCounterFactory(clockService::current, clusterSvc.messagingService());
-
-        distributedTblMgr = new TableManager(
-                name,
-                registry,
-                gcConfig,
-                replicationConfig,
-                messagingServiceReturningToStorageOperationsPool,
-                clusterSvc.topologyService(),
-                lockMgr,
-                replicaSvc,
-                txManager,
-                dataStorageMgr,
-                metaStorageMgr,
-                schemaManager,
-                validationSchemasSource,
-                threadPoolsManager.tableIoExecutor(),
-                threadPoolsManager.partitionOperationsExecutor(),
-                clockService,
-                outgoingSnapshotsManager,
-                schemaSyncService,
-                catalogManager,
-                failureManager,
-                observableTimestampTracker,
-                placementDriverMgr.placementDriver(),
-                this::bareSql,
-                resourcesRegistry,
-                lowWatermark,
-                transactionInflights,
-                indexMetaStorage,
-                partitionReplicaLifecycleManager,
-                minTimeCollectorService,
-                systemDistributedConfiguration,
-                metricManager,
-                partitionModificationCounterFactory
-        );
-
-        disasterRecoveryManager = new DisasterRecoveryManager(
-                threadPoolsManager.tableIoExecutor(),
-                messagingServiceReturningToStorageOperationsPool,
-                metaStorageMgr,
-                catalogManager,
-                distributionZoneManager,
-                raftMgr,
-                clusterSvc.topologyService(),
-                logicalTopologyService,
-                distributedTblMgr,
-                metricManager,
-                failureManager,
-                partitionReplicaLifecycleManager,
-                systemViewManager
-        );
-
-        indexManager = new IndexManager(
-                schemaManager,
-                distributedTblMgr,
-                catalogManager,
-                threadPoolsManager.tableIoExecutor(),
-                registry,
-                lowWatermark
-        );
-
-        indexBuildingManager = new IndexBuildingManager(
-                name,
-                replicaSvc,
-                catalogManager,
-                metaStorageMgr,
-                indexManager,
-                indexMetaStorage,
-                placementDriverMgr.placementDriver(),
-                clusterSvc,
-                logicalTopologyService,
-                clockService,
-                failureManager,
-                lowWatermark,
-                txManager,
-                partitionReplicaLifecycleManager,
-                metricManager
-        );
-
-        qryEngine = new SqlQueryProcessor(
-                clusterSvc,
-                logicalTopologyService,
-                distributedTblMgr,
-                schemaManager,
-                replicaSvc,
-                clockService,
-                schemaSyncService,
-                catalogManager,
-                metricManager,
-                systemViewManager,
-                failureManager,
-                placementDriverMgr.placementDriver(),
-                clusterConfigRegistry.getConfiguration(SqlClusterExtensionConfiguration.KEY).sql(),
-                nodeConfigRegistry.getConfiguration(SqlNodeExtensionConfiguration.KEY).sql(),
-                transactionInflights,
-                txManager,
-                lowWatermark,
-                threadPoolsManager.commonScheduler(),
-                killCommandHandler,
-                eventLog
-        );
-
-        systemViewManager.register(qryEngine);
-
-        sql = new IgniteSqlImpl(qryEngine, observableTimestampTracker, threadPoolsManager.commonScheduler());
-
-        ComputeConfiguration computeCfg = nodeConfigRegistry.getConfiguration(ComputeExtensionConfiguration.KEY).compute();
-        InMemoryComputeStateMachine stateMachine = new InMemoryComputeStateMachine(computeCfg, name);
-        ComputeExecutorImpl computeExecutor = new ComputeExecutorImpl(
-                this,
-                stateMachine,
-                computeCfg,
-                clusterSvc.topologyService(),
-                clockService,
-                eventLog
-        );
-
-        var deploymentManagerImpl = new DeploymentManagerImpl(
-                clusterSvc,
-                new DeploymentUnitStoreImpl(metaStorageMgr),
-                logicalTopologyService,
-                workDir,
-                nodeConfigRegistry.getConfiguration(DeploymentExtensionConfiguration.KEY).deployment(),
-                cmgMgr,
-                name,
-                computeExecutor::onUnitRemoving // TODO IGNITE-25759 cleaner platform unit removal.
-        );
-        deploymentManager = deploymentManagerImpl;
-
-        computeComponent = new ComputeComponentImpl(
-                name,
-                clusterSvc.messagingService(),
-                clusterSvc.topologyService(),
-                logicalTopologyService,
-                new UnitsContextManager(
-                        deploymentManagerImpl,
-                        deploymentManagerImpl.deploymentUnitAccessor(),
-                        new UnitsClassLoaderFactory()
-                ),
-                computeExecutor,
-                computeCfg,
-                eventLog,
-                observableTimestampTracker
-        );
-
-        systemViewManager.register(computeComponent);
-
-        compute = new IgniteComputeImpl(
-                name,
-                placementDriverMgr.placementDriver(),
-                clusterSvc.topologyService(),
-                distributedTblMgr,
-                computeComponent,
-                clock,
-                observableTimestampTracker
-        );
-
-        killCommandHandler.register(computeKillHandler(compute));
-
-        authenticationManager = createAuthenticationManager();
-
-        ClientConnectorConfiguration clientConnectorConfiguration = nodeConfigRegistry
-                .getConfiguration(ClientConnectorExtensionConfiguration.KEY).clientConnector();
-
-        SuggestionsConfiguration suggestionsConfiguration = clusterConfigRegistry
-                .getConfiguration(SuggestionsClusterExtensionConfiguration.KEY).suggestions();
-
-        clientHandlerModule = new ClientHandlerModule(
-                qryEngine,
-                distributedTblMgr,
-                txManager,
-                compute,
-                clusterSvc,
-                nettyBootstrapFactory,
-                () -> {
-                    ClusterState localClusterState = clusterState();
-
-                    return new ClusterInfo(localClusterState.clusterTag(), localClusterState.clusterIdHistory());
-                },
-                metricManager,
-                new ClientHandlerMetricSource(),
-                authenticationManager,
-                clockService,
-                schemaSyncService,
-                catalogManager,
-                placementDriverMgr.placementDriver(),
-                clientConnectorConfiguration,
-                eventLog,
-                lowWatermark,
-                threadPoolsManager.partitionOperationsExecutor(),
-                () -> suggestionsConfiguration.sequentialDdlExecution().enabled().value()
-        );
-
-        computeExecutor.setPlatformComputeTransport(clientHandlerModule);
-
-        metricMessaging = new MetricMessaging(metricManager, clusterSvc.messagingService(), clusterSvc.topologyService());
-        systemPropertiesComponent = new SystemPropertiesComponent(systemDistributedConfiguration);
-
+        // Resolve all DI-managed components. Bean creation is lazy — requesting the first bean triggers
+        // its construction plus all transitive dependencies. By the time we're done, all beans are created.
+
+        // Phase 1 components (pre-join). Only fields still used outside the constructor are resolved.
+        metricManager = diContext.getBean(MetricManagerImpl.class);
+        vaultMgr = diContext.getBean(VaultManager.class);
+        nodeProperties = diContext.getBean(NodePropertiesImpl.class);
+        failureManager = diContext.getBean(FailureManager.class);
+        clusterIdService = diContext.getBean(ClusterIdService.class);
+        nettyBootstrapFactory = diContext.getBean(NettyBootstrapFactory.class);
+        clusterSvc = diContext.getBean(ClusterService.class);
+        clock = diContext.getBean(HybridClock.class);
+        clusterStateStorage = diContext.getBean(ClusterStateStorage.class);
+        systemDisasterRecoveryManager = diContext.getBean(SystemDisasterRecoveryManagerImpl.class);
+        partitionsLogStorageManager = diContext.getBean(LogStorageManager.class, Qualifiers.byName("partitions"));
+        partitionsWorkDir = diContext.getBean(ComponentWorkingDir.class, Qualifiers.byName("partitions"));
+        metastorageWorkDir = diContext.getBean(ComponentWorkingDir.class, Qualifiers.byName("metastorage"));
+        raftMgr = diContext.getBean(Loza.class);
+        cmgMgr = diContext.getBean(ClusterManagementGroupManager.class);
+        logicalTopologyService = diContext.getBean(LogicalTopologyService.class);
+        clusterInitializer = diContext.getBean(ClusterInitializer.class);
+        lowWatermark = diContext.getBean(LowWatermarkImpl.class);
+
+        // Phase 2 components (post-join).
+        metaStorageMgr = diContext.getBean(MetaStorageManagerImpl.class);
+        clusterConfigRegistry = diContext.getBean(ConfigurationRegistry.class, Qualifiers.byName("clusterConfig"));
+        cfgStorage = diContext.getBean(DistributedConfigurationStorage.class);
+        eventLog = diContext.getBean(EventLogImpl.class);
+        clockService = diContext.getBean(ClockServiceImpl.class);
+        catalogManager = diContext.getBean(CatalogManagerImpl.class);
+        catalogCompactionRunner = diContext.getBean(CatalogCompactionRunner.class);
+        placementDriverMgr = diContext.getBean(PlacementDriverManager.class);
+        schemaSafeTimeTracker = diContext.getBean(SchemaSafeTimeTrackerImpl.class);
+        replicaMgr = diContext.getBean(ReplicaManager.class);
+        txManager = diContext.getBean(TxManagerImpl.class);
+        distributionZoneManager = diContext.getBean(DistributionZoneManager.class);
+        sharedTxStateStorage = diContext.getBean(TxStateRocksDbSharedStorage.class);
+        partitionReplicaLifecycleManager = diContext.getBean(PartitionReplicaLifecycleManager.class);
+        distributedTblMgr = diContext.getBean(TableManager.class);
+        disasterRecoveryManager = diContext.getBean(DisasterRecoveryManager.class);
+        qryEngine = diContext.getBean(SqlQueryProcessor.class);
+        sql = diContext.getBean(IgniteSqlImpl.class);
+        killCommandHandler = diContext.getBean(KillCommandHandler.class);
+        computeComponent = diContext.getBean(ComputeComponentImpl.class);
+        compute = diContext.getBean(IgniteComputeInternal.class);
+        deploymentManager = diContext.getBean(DeploymentManagerImpl.class);
+        authenticationManager = diContext.getBean(AuthenticationManager.class);
+        clientHandlerModule = diContext.getBean(ClientHandlerModule.class);
+        resourcesRegistry = diContext.getBean(RemotelyTriggeredResourceRegistry.class);
+        metricMessaging = diContext.getBean(MetricMessaging.class);
+        partitionCountCalculatorWrapper = diContext.getBean(PartitionCountCalculatorWrapper.class);
+        systemViewManager = diContext.getBean(SystemViewManagerImpl.class);
+        observableTimestampTracker = diContext.getBean(HybridTimestampTracker.class);
+        dataStorageMgr = diContext.getBean(DataStorageManager.class);
+
+        // Initialize the DI component lifecycle manager. Exclude components with special startup ordering:
+        // nodeConfigRegistry — started early in constructor, before other beans are created
+        // clusterConfigRegistry — started manually in joinClusterAsync() (after MetaStorage recovery)
+        // metaStorageMgr — started manually in joinClusterAsync() (must start before cluster config init)
+        // systemViewManager — must start last, after all system view registrations
+        componentLifecycleManager = new IgniteComponentLifecycleManager(diContext);
+        componentLifecycleManager.exclude(nodeConfigRegistry, clusterConfigRegistry, metaStorageMgr, systemViewManager);
+
+        // nodeConfigRegistry was already started above; register it for proper reverse-order shutdown.
+        componentLifecycleManager.markAsStarted(nodeConfigRegistry);
+
+        // Post-construction wiring: cross-component hookups that cannot be expressed as constructor injection.
+        // These are all listener/callback registrations that just store references; they don't require
+        // components to be started yet.
+        PostConstructionWiring wiring = diContext.getBean(PostConstructionWiring.class);
+        wiring.wirePhase2();
+
+        // REST component (depends on joinFuture and lifecycle state, created manually).
         restComponent = createRestComponent(name);
 
+        // Public API wrappers.
         publicTables = new PublicApiThreadingIgniteTables(distributedTblMgr, asyncContinuationExecutor);
         publicTransactions = new PublicApiThreadingIgniteTransactions(
                 new IgniteTransactionsImpl(txManager, observableTimestampTracker), asyncContinuationExecutor
@@ -1355,40 +474,6 @@ public class IgniteImpl implements Ignite {
         publicCluster = new PublicApiThreadingIgniteCluster(new IgniteClusterImpl(clusterSvc.topologyService(), clusterIdService));
     }
 
-    private GroupStoragesContextResolver createGroupStoragesContextResolver() {
-        Map<String, LogStorageManager> logStorageManagerByGroupName = Map.of(
-                PARTITION_GROUP_NAME, partitionsLogStorageManager,
-                MetastorageGroupId.INSTANCE.toString(), msLogStorageManager,
-                CmgGroupId.INSTANCE.toString(), cmgLogStorageManager
-        );
-
-        Map<String, Path> serverDataPathByGroupName = Map.of(
-                PARTITION_GROUP_NAME, partitionsWorkDir.metaPath(),
-                MetastorageGroupId.INSTANCE.toString(), metastorageWorkDir.metaPath(),
-                CmgGroupId.INSTANCE.toString(), cmgWorkDir.metaPath()
-        );
-
-        return new GroupStoragesContextResolver(
-                replicationGroupId -> replicationGroupId instanceof PartitionGroupId ? PARTITION_GROUP_NAME : replicationGroupId.toString(),
-                serverDataPathByGroupName,
-                logStorageManagerByGroupName
-        );
-    }
-
-    private static LogicalTopologyEventListener logicalTopologyJoinedNodesListener(LogicalTopologyEventsListener listener) {
-        return new LogicalTopologyEventListener() {
-            @Override
-            public void onNodeJoined(LogicalNode joinedNode, LogicalTopologySnapshot newTopology) {
-                listener.onJoined(joinedNode, newTopology.version());
-            }
-
-            @Override
-            public void onNodeLeft(LogicalNode leftNode, LogicalTopologySnapshot newTopology) {
-                listener.onLeft(leftNode, newTopology.version());
-            }
-        };
-    }
-
     private ClusterState clusterState() {
         ClusterState localClusterState = clusterState;
 
@@ -1397,37 +482,10 @@ private ClusterState clusterState() {
         return localClusterState;
     }
 
-    private static Map<String, StorageEngine> applyThreadAssertionsIfNeeded(Map<String, StorageEngine> storageEngines) {
-        boolean enabled = ThreadAssertions.enabled();
-
-        LOG.info("Thread assertions enablement status: {}", enabled);
-
-        if (!enabled) {
-            return storageEngines;
-        }
-
-        Map<String, StorageEngine> decoratedEngines = new HashMap<>();
-
-        for (Entry<String, StorageEngine> entry : storageEngines.entrySet()) {
-            decoratedEngines.put(entry.getKey(), new ThreadAssertingStorageEngine(entry.getValue()));
-        }
-
-        return Map.copyOf(decoratedEngines);
-    }
-
-    private static LongSupplier delayDurationMsSupplier(SchemaSynchronizationConfiguration schemaSyncConfig) {
-        return () -> schemaSyncConfig.delayDurationMillis().value();
-    }
-
-    private static LongSupplier partitionIdleSafeTimePropagationPeriodMsSupplier(ReplicationConfiguration replicationConfig) {
-        return () -> replicationConfig.idleSafeTimePropagationDurationMillis().value();
-    }
-
-    private AuthenticationManager createAuthenticationManager() {
-        SecurityConfiguration securityConfiguration = clusterConfigRegistry
-                .getConfiguration(SecurityExtensionConfiguration.KEY).security();
-
-        return new AuthenticationManagerImpl(securityConfiguration, eventLog);
+    /** Returns cluster info from the cached cluster state. Used by the client handler to avoid blocking RPC calls. */
+    public ClusterInfo clusterInfo() {
+        ClusterState state = clusterState();
+        return new ClusterInfo(state.clusterTag(), state.clusterIdHistory());
     }
 
     private RestComponent createRestComponent(String name) {
@@ -1439,8 +497,9 @@ private RestComponent createRestComponent(String name) {
                 cmgMgr,
                 () -> joinFuture
         );
-        Supplier<RestFactory> nodeManagementRestFactory = () -> new NodeManagementRestFactory(lifecycleManager, () -> name,
-                new JdbcPortProviderImpl(nodeConfigRegistry));
+        JdbcPortProvider jdbcPortProvider = diContext.getBean(JdbcPortProvider.class);
+        Supplier<RestFactory> nodeManagementRestFactory =
+                () -> new NodeManagementRestFactory(lifecycleManager, () -> name, jdbcPortProvider);
         Supplier<RestFactory> metricRestFactory = () -> new MetricRestFactory(metricManager, metricMessaging);
         Supplier<RestFactory> authProviderFactory = () -> new AuthenticationProviderFactory(authenticationManager);
         Supplier<RestFactory> deploymentCodeRestFactory =
@@ -1477,16 +536,6 @@ private RestComponent createRestComponent(String name) {
         );
     }
 
-    private static MessageSerializationRegistry createSerializationRegistry(@Nullable ClassLoader classLoader) {
-        var serviceLoader = new SerializationRegistryServiceLoader(classLoader);
-
-        var serializationRegistry = new MessageSerializationRegistryImpl();
-
-        serviceLoader.registerSerializationFactories(serializationRegistry);
-
-        return serializationRegistry;
-    }
-
     /**
      * Starts ignite node.
      *
@@ -1502,46 +551,19 @@ CompletableFuture<Void> startAsync() {
         ComponentContext componentContext = new ComponentContext(startupExecutor);
 
         try {
-            JvmMetricSource jvmMetrics = new JvmMetricSource();
-            metricManager.registerSource(jvmMetrics);
-            metricManager.enable(jvmMetrics);
-
-            OsMetricSource osMetrics = new OsMetricSource();
-            metricManager.registerSource(osMetrics);
-            metricManager.enable(osMetrics);
-
-            metricManager.registerSource(clockServiceMetricSource);
-            metricManager.enable(clockServiceMetricSource);
-
-            partitionModificationCounterFactory.start();
-
-            // Start the components that are required to join the cluster.
-            // TODO https://issues.apache.org/jira/browse/IGNITE-22570
-            CompletableFuture<Void> componentsStartFuture = lifecycleManager.startComponentsAsync(
-                    componentContext,
-                    longJvmPauseDetector,
-                    vaultMgr,
-                    nodeProperties,
-                    threadPoolsManager,
-                    clockWaiter,
-                    failureManager,
-                    clusterStateStorage,
-                    clusterIdService,
-                    systemDisasterRecoveryManager,
-                    criticalWorkerRegistry,
-                    nettyBootstrapFactory,
-                    nettyWorkersRegistrar,
-                    clusterSvc,
-                    restComponent,
-                    partitionsLogStorageManager,
-                    msLogStorageManager,
-                    cmgLogStorageManager,
-                    raftMgr,
-                    cmgMgr,
-                    lowWatermark
-            );
-
-            return componentsStartFuture
+            // Pre-start wiring: register metric sources and start partition modification counters.
+            PostConstructionWiring wiring = diContext.getBean(PostConstructionWiring.class);
+            wiring.wirePhase1();
+
+            // Start REST component separately (not DI-managed, depends on joinFuture).
+            // Register before PHASE_1 so it's stopped after PHASE_1 components during reverse-order shutdown.
+            CompletableFuture<Void> restStartFuture = lifecycleManager.startComponentAsync(restComponent, componentContext);
+            componentLifecycleManager.markAsStarted(restComponent);
+
+            // Start all PHASE_1 DI-managed components.
+            CompletableFuture<Void> phase1Future = componentLifecycleManager.startPhase(StartupPhase.PHASE_1, componentContext);
+
+            return CompletableFuture.allOf(restStartFuture, phase1Future)
                     .thenRunAsync(() -> {
                         vaultMgr.putName(name);
 
@@ -1591,6 +613,9 @@ CompletableFuture<Ignite> joinClusterAsync() {
                 .thenComposeAsync(unused -> {
                     LOG.info("Join complete, starting MetaStorage");
 
+                    // Register with componentLifecycleManager BEFORE starting, so that stopAll()
+                    // will know about this component even if a concurrent stop races with the start.
+                    componentLifecycleManager.markAsStarted(metaStorageMgr);
                     try {
                         lifecycleManager.startComponentAsync(metaStorageMgr, componentContext);
                     } catch (NodeStoppingException e) {
@@ -1601,62 +626,49 @@ CompletableFuture<Ignite> joinClusterAsync() {
                 }, joinExecutor)
                 .thenComposeAsync(unused -> initializeClusterConfiguration(joinExecutor), joinExecutor)
                 .thenRunAsync(() -> {
+                    // Start cluster config registry after MetaStorage recovery (it depends on DistributedConfigurationStorage).
+                    componentLifecycleManager.markAsStarted(clusterConfigRegistry);
+                    try {
+                        lifecycleManager.startComponentAsync(clusterConfigRegistry, componentContext);
+                    } catch (NodeStoppingException e) {
+                        throw new CompletionException(e);
+                    }
+                }, joinExecutor)
+                .<CompletableFuture<Void>>thenApplyAsync(unused -> {
                     LOG.info("MetaStorage started, starting the remaining components");
 
-                    // Start all other components after the join request has completed and the node has been validated.
+                    // Fire-and-forget: start all PHASE_2 DI-managed components.
+                    // We don't wait for them here because some components' startAsync() may need
+                    // MetaStorage revision notifications (delivered by notifyRevisionUpdateListenerOnStart).
+                    // Waiting here would deadlock on restart.
+                    CompletableFuture<Void> phase2Future = componentLifecycleManager.startPhase(
+                            StartupPhase.PHASE_2, componentContext
+                    );
+
+                    // The system view manager comes last because other components
+                    // must register system views before it starts.
+                    componentLifecycleManager.markAsStarted(systemViewManager);
                     try {
-                        lifecycleManager.startComponentsAsync(
-                                componentContext,
-                                catalogManager,
-                                new LowWatermarkRectifier(lowWatermark, catalogManager),
-                                catalogCompactionRunner,
-                                indexMetaStorage,
-                                clusterConfigRegistry,
-                                idempotentCacheVacuumizer,
-                                authenticationManager,
-                                placementDriverMgr,
-                                metricManager,
-                                metricMessaging,
-                                distributionZoneManager,
-                                computeComponent,
-                                volatileLogStorageManagerCreator,
-                                logStorageMetrics,
-                                replicaMgr,
-                                indexNodeFinishedRwTransactionsChecker,
-                                txManager,
-                                dataStorageMgr,
-                                schemaSafeTimeTracker,
-                                schemaManager,
-                                outgoingSnapshotsManager,
-                                sharedTxStateStorage,
-                                partitionReplicaLifecycleManager,
-                                distributedTblMgr,
-                                disasterRecoveryManager,
-                                indexManager,
-                                indexBuildingManager,
-                                qryEngine,
-                                clientHandlerModule,
-                                deploymentManager,
-                                sql,
-                                systemPropertiesComponent,
-                                resourceVacuumManager,
-                                metaStorageCompactionTrigger,
-                                eventLog
-                        );
-
-                        // The system view manager comes last because other components
-                        // must register system views before it starts.
                         lifecycleManager.startComponentAsync(systemViewManager, componentContext);
                     } catch (NodeStoppingException e) {
                         throw new CompletionException(e);
                     }
+
+                    return phase2Future;
                 }, joinExecutor)
-                .thenComposeAsync(v -> {
+                .thenComposeAsync(phase2Future -> {
                     LOG.info("Components started, performing recovery");
 
                     LOG.info("Cluster configuration: {}", convertToHoconString(clusterConfigRegistry));
 
-                    return recoverComponentsStateOnStart(joinExecutor, lifecycleManager.allComponentsStartFuture(joinExecutor));
+                    // Wait for ALL component starts (both DI-managed PHASE_2 and manually-started)
+                    // plus revision update before deploying watches.
+                    CompletableFuture<Void> allStartsFuture = CompletableFuture.allOf(
+                            phase2Future,
+                            lifecycleManager.allComponentsStartFuture(joinExecutor)
+                    );
+
+                    return recoverComponentsStateOnStart(joinExecutor, allStartsFuture);
                 }, joinExecutor)
                 .thenComposeAsync(v -> clusterConfigRegistry.onDefaultsPersisted(), joinExecutor)
                 // Signal that local recovery is complete and the node is ready to join the cluster.
@@ -1754,17 +766,13 @@ private RuntimeException handleStartException(Throwable e) {
             LOG.error(errMsg, igniteException);
         }
 
-        ExecutorService lifecycleExecutor = stopExecutor();
-
         try {
-            lifecycleManager.stopNode(new ComponentContext(lifecycleExecutor)).get();
+            stopAsync().get();
         } catch (Throwable ex) {
             // We add ex as a suppressed subexception, but we don't know how the caller will handle it, so we also log it ourselves.
             LOG.error("Node stop failed after node start failure", ex);
 
             igniteException.addSuppressed(ex);
-        } finally {
-            lifecycleExecutor.shutdownNow();
         }
 
         return igniteException;
@@ -1786,12 +794,22 @@ public CompletableFuture<Void> stopAsync() {
         }
 
         ExecutorService lifecycleExecutor = stopExecutor();
+        ComponentContext componentContext = new ComponentContext(lifecycleExecutor);
 
+        lifecycleManager.markAsStopping();
         cmgMgr.markAsStopping();
         metaStorageMgr.markAsStopping();
 
-        // TODO https://issues.apache.org/jira/browse/IGNITE-22570
-        lifecycleManager.stopNode(new ComponentContext(lifecycleExecutor))
+        // Stop ALL components in reverse start order. The componentLifecycleManager tracks both
+        // DI-managed and manually-started components (via markAsStarted) in the correct order.
+        componentLifecycleManager.stopAll(componentContext)
+                .whenCompleteAsync((res, ex) -> {
+                    try {
+                        diContext.close();
+                    } catch (Exception e) {
+                        LOG.warn("Failed to close DI context", e);
+                    }
+                })
                 // Moving to the common pool on purpose to close the stop pool and proceed user's code in the common pool.
                 .whenCompleteAsync((res, ex) -> lifecycleExecutor.shutdownNow())
                 .whenCompleteAsync(copyStateTo(stopFuture));
@@ -1860,16 +878,17 @@ public TableManager distributedTableManager() {
         return distributedTblMgr;
     }
 
+    @TestOnly
+    public DataStorageManager dataStorageManager() {
+        return dataStorageMgr;
+    }
+
     /** {@inheritDoc} */
     @Override
     public IgniteTransactions transactions() {
         return publicTransactions;
     }
 
-    private IgniteSql bareSql() {
-        return sql;
-    }
-
     /** {@inheritDoc} */
     @Override
     public IgniteSql sql() {
@@ -2028,51 +1047,6 @@ private CompletableFuture<?> recoverComponentsStateOnStart(ExecutorService start
                 }, startupExecutor);
     }
 
-    /** Returns a {@link OperationKillHandler kill handler} for the compute job. */
-    private static OperationKillHandler computeKillHandler(IgniteComputeInternal compute) {
-        return new OperationKillHandler() {
-            @Override
-            public CompletableFuture<Boolean> cancelAsync(String operationId) {
-                UUID jobId = UUID.fromString(operationId);
-
-                return compute.cancelAsync(jobId)
-                        .thenApply(res -> res != null ? res : Boolean.FALSE);
-            }
-
-            @Override
-            public boolean local() {
-                return false;
-            }
-
-            @Override
-            public CancellableOperationType type() {
-                return CancellableOperationType.COMPUTE;
-            }
-        };
-    }
-
-    /** Returns a {@link OperationKillHandler kill handler} for the transaction. */
-    private static OperationKillHandler transactionKillHandler(TxManager txManager) {
-        return new OperationKillHandler() {
-            @Override
-            public CompletableFuture<Boolean> cancelAsync(String operationId) {
-                UUID transactionId = UUID.fromString(operationId);
-
-                return txManager.kill(transactionId);
-            }
-
-            @Override
-            public boolean local() {
-                return true;
-            }
-
-            @Override
-            public CancellableOperationType type() {
-                return CancellableOperationType.TRANSACTION;
-            }
-        };
-    }
-
     @TestOnly
     public Loza raftManager() {
         return raftMgr;
@@ -2266,6 +1240,7 @@ public void dumpClusterState() {
      * "ignite{clientConnector{connectTimeoutMillis=5000,idleTimeoutMillis=0}}".
      */
     private static String convertToHoconString(ConfigurationRegistry configRegistry) {
-        return HoconConverter.represent(configRegistry.superRoot(), List.of()).render(ConfigRenderOptions.concise().setJson(false));
+        return HoconConverter.represent(((ConfigurationRegistryImpl) configRegistry).superRoot(), List.of())
+                .render(ConfigRenderOptions.concise().setJson(false));
     }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/LifecycleManager.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/LifecycleManager.java
index e1361101337c..d2b774defd66 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/LifecycleManager.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/LifecycleManager.java
@@ -144,6 +144,14 @@ synchronized CompletableFuture<Void> allComponentsStartFuture(Executor startExec
                 }, startExecutor);
     }
 
+    /**
+     * Marks the node as stopping without initiating component shutdown.
+     * This is used when component shutdown is handled by the DI lifecycle manager.
+     */
+    void markAsStopping() {
+        status.set(State.STOPPING);
+    }
+
     /**
      * Stops all started components and transfers the node into the {@link State#STOPPING} state.
      *
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
index 205580ee98e9..8fbe0ee3795b 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
@@ -20,8 +20,12 @@
 import static org.apache.ignite.internal.hlc.HybridTimestamp.hybridTimestamp;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.catalog.CatalogService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -31,11 +35,14 @@
 /**
  * Component that rectifies the low watermark on node startup if it is lower than the earliest catalog timestamp.
  */
-class LowWatermarkRectifier implements IgniteComponent {
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(200)
+public class LowWatermarkRectifier implements IgniteComponent {
     private final LowWatermark lowWatermark;
     private final CatalogService catalogService;
 
-    LowWatermarkRectifier(LowWatermark lowWatermark, CatalogService catalogService) {
+    public LowWatermarkRectifier(LowWatermark lowWatermark, CatalogService catalogService) {
         this.lowWatermark = lowWatermark;
         this.catalogService = catalogService;
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
index b58ab68ff1a7..8a89c9fb9bf9 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
@@ -22,10 +22,14 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.ILLEGAL_ARGUMENT_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Common.UNSUPPORTED_TABLE_BASED_REPLICATION_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.NodeAttributesProvider;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeProperties;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.ByteArray;
 import org.apache.ignite.internal.lang.IgniteSystemProperties;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -39,6 +43,9 @@
 /**
  * Default implementation of {@link NodeProperties} using {@link VaultManager} for persistence.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(300)
 public class NodePropertiesImpl implements NodeProperties, IgniteComponent, NodeAttributesProvider {
     private static final IgniteLogger LOG = Loggers.forClass(NodePropertiesImpl.class);
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
index 5f85e3c74ac6..129bc533de00 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
@@ -17,7 +17,11 @@
 
 package org.apache.ignite.internal.app;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -28,7 +32,10 @@
 /**
  * System properties initialization.
  */
-class SystemPropertiesComponent implements IgniteComponent {
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(3200)
+public class SystemPropertiesComponent implements IgniteComponent {
 
     /**
      * Sensitive data logging option. See {@link IgniteToStringBuilder#setSensitiveDataPolicy(SensitiveDataLoggingPolicy)}}. 
@@ -37,7 +44,8 @@ class SystemPropertiesComponent implements IgniteComponent {
 
     private final SystemDistributedConfigurationPropertyHolder<SensitiveDataLoggingPolicy> sensitiveDataLogging;
 
-    SystemPropertiesComponent(SystemDistributedConfiguration configuration) {
+    /** Constructor. */
+    public SystemPropertiesComponent(SystemDistributedConfiguration configuration) {
         this.sensitiveDataLogging = new SystemDistributedConfigurationPropertyHolder<>(
                 configuration,
                 (value, revision) -> IgniteToStringBuilder.setSensitiveDataPolicy(value),
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
index 3f8f9bb5c4e6..e63d9ab63798 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.app;
 
+import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.apache.ignite.internal.metrics.sources.ThreadPoolMetricSource.THREAD_POOLS_METRICS_SOURCE_NAME;
 import static org.apache.ignite.internal.thread.ThreadOperation.PROCESS_RAFT_REQ;
@@ -25,6 +26,10 @@
 import static org.apache.ignite.internal.thread.ThreadOperation.TX_STATE_STORAGE_ACCESS;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -32,6 +37,7 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadPoolExecutor;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -44,6 +50,7 @@
 /**
  * Component that hosts thread pools which do not belong to a certain component and which are global to an Ignite instance.
  */
+@Factory
 public class ThreadPoolsManager implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(ThreadPoolsManager.class);
 
@@ -67,6 +74,12 @@ public class ThreadPoolsManager implements IgniteComponent {
 
     private final List<ThreadPoolMetricSource> metricSources;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public ThreadPoolsManager(NodeIdentity nodeIdentity, MetricManager metricManager) {
+        this(nodeIdentity.nodeName(), metricManager);
+    }
+
     /**
      * Constructor.
      */
@@ -92,9 +105,9 @@ public ThreadPoolsManager(String nodeName, MetricManager metricManager) {
                 )
         );
 
-        commonScheduler = Executors.newSingleThreadScheduledExecutor(IgniteThreadFactory.create(nodeName, "common-scheduler", LOG));
+        commonScheduler = newSingleThreadScheduledExecutor(IgniteThreadFactory.create(nodeName, "common-scheduler", LOG));
 
-        rebalanceScheduler = Executors.newSingleThreadScheduledExecutor(IgniteThreadFactory.create(nodeName, "rebalance-scheduler", LOG));
+        rebalanceScheduler = newSingleThreadScheduledExecutor(IgniteThreadFactory.create(nodeName, "rebalance-scheduler", LOG));
 
         this.metricManager = metricManager;
 
@@ -130,6 +143,8 @@ public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
     /**
      * Returns executor used to create/destroy storages, start partition Raft groups, create index storages...
      */
+    @Singleton
+    @Named("tableIoExecutor")
     public ScheduledExecutorService tableIoExecutor() {
         return tableIoExecutor;
     }
@@ -137,6 +152,8 @@ public ScheduledExecutorService tableIoExecutor() {
     /**
      * Returns the executor of partition operations.
      */
+    @Singleton
+    @Named("partitionOperationsExecutor")
     public ExecutorService partitionOperationsExecutor() {
         return partitionOperationsExecutor;
     }
@@ -144,11 +161,15 @@ public ExecutorService partitionOperationsExecutor() {
     /**
      * Returns a global {@link ScheduledExecutorService}. Only small tasks should be scheduled.
      */
+    @Singleton
+    @Named("commonScheduler")
     public ScheduledExecutorService commonScheduler() {
         return commonScheduler;
     }
 
     /** Returns executor for scheduling rebalance routine. */
+    @Singleton
+    @Named("rebalanceScheduler")
     public ScheduledExecutorService rebalanceScheduler() {
         return rebalanceScheduler;
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
new file mode 100644
index 000000000000..c34cb3d49099
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -0,0 +1,143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.ClockService;
+import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.ClockWaiter;
+import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
+import org.apache.ignite.internal.metastorage.cache.IdempotentCacheVacuumizer;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.metrics.sources.ClockServiceMetricSource;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
+import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.raft.RaftManager;
+import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
+import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
+
+/**
+ * Micronaut factory for catalog, clock service, and placement driver components.
+ */
+@Factory
+public class CatalogFactory {
+    /** Creates the clock service. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(50)
+    public ClockServiceImpl clockService(
+            HybridClock clock,
+            ClockWaiter clockWaiter,
+            SchemaSynchronizationConfiguration schemaSyncConfig,
+            ClockServiceMetricSource clockServiceMetricSource
+    ) {
+        return new ClockServiceImpl(
+                clock,
+                clockWaiter,
+                () -> schemaSyncConfig.maxClockSkewMillis().value(),
+                clockServiceMetricSource::onMaxClockSkewExceeded
+        );
+    }
+
+    /** Creates the idempotent cache vacuumizer. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(600)
+    public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
+            NodeIdentity nodeIdentity,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
+            MetaStorageManagerImpl metaStorageManager,
+            RaftConfiguration raftConfiguration,
+            ClockService clockService,
+            FailureManager failureManager
+    ) {
+        return new IdempotentCacheVacuumizer(
+                nodeIdentity.nodeName(),
+                commonScheduler,
+                metaStorageManager::evictIdempotentCommandsCache,
+                raftConfiguration.retryTimeoutMillis(),
+                clockService,
+                failureManager,
+                1,
+                1,
+                TimeUnit.MINUTES
+        );
+    }
+
+    /** Creates the placement driver manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(800)
+    public PlacementDriverManager placementDriverManager(
+            NodeIdentity nodeIdentity,
+            MetaStorageManager metaStorageManager,
+            ClusterService clusterService,
+            ClusterManagementGroupManager cmgManager,
+            LogicalTopologyService logicalTopologyService,
+            RaftManager raftManager,
+            TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
+            ClockService clockService,
+            FailureManager failureManager,
+            ReplicationConfiguration replicationConfiguration,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
+            MetricManager metricManager,
+            Provider<DistributionZoneManager> distributionZoneManagerProvider
+    ) {
+        return new PlacementDriverManager(
+                nodeIdentity.nodeName(),
+                metaStorageManager,
+                MetastorageGroupId.INSTANCE,
+                clusterService,
+                cmgManager::metaStorageNodes,
+                logicalTopologyService,
+                raftManager,
+                topologyAwareRaftGroupServiceFactory,
+                clockService,
+                failureManager,
+                replicationConfiguration,
+                commonScheduler,
+                metricManager,
+                zoneId -> distributionZoneManagerProvider.get().currentDataNodes(zoneId)
+        );
+    }
+
+    /** Exposes the placement driver as a bean. */
+    @Singleton
+    public PlacementDriver placementDriver(PlacementDriverManager placementDriverManager) {
+        return placementDriverManager.placementDriver();
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
new file mode 100644
index 000000000000..c67dd2a1c576
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -0,0 +1,127 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import java.util.concurrent.ExecutorService;
+import org.apache.ignite.client.handler.ClientHandlerMetricSource;
+import org.apache.ignite.client.handler.ClientHandlerModule;
+import org.apache.ignite.client.handler.configuration.ClientConnectorConfiguration;
+import org.apache.ignite.client.handler.configuration.ClientConnectorExtensionConfiguration;
+import org.apache.ignite.internal.app.IgniteImpl;
+import org.apache.ignite.internal.catalog.CatalogManager;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.compute.IgniteComputeInternal;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SuggestionsClusterExtensionConfiguration;
+import org.apache.ignite.internal.configuration.SuggestionsConfiguration;
+import org.apache.ignite.internal.eventlog.api.EventLog;
+import org.apache.ignite.internal.hlc.ClockService;
+import org.apache.ignite.internal.lowwatermark.LowWatermark;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.NettyBootstrapFactory;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
+import org.apache.ignite.internal.schema.SchemaSyncService;
+import org.apache.ignite.internal.security.authentication.AuthenticationManager;
+import org.apache.ignite.internal.security.configuration.SecurityConfiguration;
+import org.apache.ignite.internal.security.configuration.SecurityExtensionConfiguration;
+import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
+import org.apache.ignite.internal.table.distributed.TableManager;
+import org.apache.ignite.internal.tx.TxManager;
+
+/**
+ * Micronaut factory for client handler and authentication components.
+ */
+@Factory
+public class ClientHandlerFactory {
+    /** Creates the security configuration from the cluster config registry. */
+    @Singleton
+    public SecurityConfiguration securityConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(SecurityExtensionConfiguration.KEY).security();
+    }
+
+    /** Creates the client connector configuration from the node config registry. */
+    @Singleton
+    public ClientConnectorConfiguration clientConnectorConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(ClientConnectorExtensionConfiguration.KEY).clientConnector();
+    }
+
+    /** Creates the suggestions configuration from the cluster config registry. */
+    @Singleton
+    public SuggestionsConfiguration suggestionsConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(SuggestionsClusterExtensionConfiguration.KEY).suggestions();
+    }
+
+    /** Creates the client handler module. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2900)
+    public ClientHandlerModule clientHandlerModule(
+            SqlQueryProcessor sqlQueryProcessor,
+            TableManager tableManager,
+            TxManager txManager,
+            IgniteComputeInternal compute,
+            ClusterService clusterService,
+            NettyBootstrapFactory nettyBootstrapFactory,
+            IgniteImpl igniteImpl,
+            MetricManager metricManager,
+            AuthenticationManager authenticationManager,
+            ClockService clockService,
+            SchemaSyncService schemaSyncService,
+            CatalogManager catalogManager,
+            PlacementDriver placementDriver,
+            ClientConnectorConfiguration clientConnectorConfiguration,
+            EventLog eventLog,
+            LowWatermark lowWatermark,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
+            SuggestionsConfiguration suggestionsConfiguration
+    ) {
+        return new ClientHandlerModule(
+                sqlQueryProcessor,
+                tableManager,
+                txManager,
+                compute,
+                clusterService,
+                nettyBootstrapFactory,
+                igniteImpl::clusterInfo,
+                metricManager,
+                new ClientHandlerMetricSource(),
+                authenticationManager,
+                clockService,
+                schemaSyncService,
+                catalogManager,
+                placementDriver,
+                clientConnectorConfiguration,
+                eventLog,
+                lowWatermark,
+                partitionOperationsExecutor,
+                () -> suggestionsConfiguration.sequentialDdlExecution().enabled().value()
+        );
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
new file mode 100644
index 000000000000..1d998d4f8111
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesConfiguration;
+import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesExtensionConfiguration;
+import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.MessagingService;
+import org.apache.ignite.internal.network.TopologyService;
+import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
+import org.apache.ignite.internal.storage.configurations.StorageExtensionConfiguration;
+
+/**
+ * Micronaut factory for cluster management components.
+ */
+@Factory
+public class ClusterManagementFactory {
+    /** Exposes the cluster messaging service as a named bean. */
+    @Singleton
+    @Named("clusterMessaging")
+    public MessagingService clusterMessagingService(ClusterService clusterService) {
+        return clusterService.messagingService();
+    }
+
+    /** Exposes the cluster topology service as a bean. */
+    @Singleton
+    public TopologyService clusterTopologyService(ClusterService clusterService) {
+        return clusterService.topologyService();
+    }
+
+    /** Creates the node attributes configuration from the node config registry. */
+    @Singleton
+    public NodeAttributesConfiguration nodeAttributesConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(NodeAttributesExtensionConfiguration.KEY).nodeAttributes();
+    }
+
+    /** Creates the storage profiles configuration from the node config registry. */
+    @Singleton
+    public StorageConfiguration storageConfiguration(@Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry) {
+        return nodeConfigRegistry.getConfiguration(StorageExtensionConfiguration.KEY).storage();
+    }
+
+    /** Creates the distributed configuration tree generator. */
+    @Singleton
+    @Named("distributed")
+    public ConfigurationTreeGenerator distributedConfigurationTreeGenerator(ConfigurationModules modules) {
+        return new ConfigurationTreeGenerator(
+                modules.distributed().rootKeys(),
+                modules.distributed().schemaExtensions(),
+                modules.distributed().polymorphicSchemaExtensions()
+        );
+    }
+
+    /** Creates the distributed configuration validator. */
+    @Singleton
+    @Named("distributed")
+    public ConfigurationValidator distributedConfigurationValidator(
+            @Named("distributed") ConfigurationTreeGenerator generator,
+            ConfigurationModules modules
+    ) {
+        return ConfigurationValidatorImpl.withDefaultValidators(generator, modules.distributed().validators());
+    }
+
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComponentWorkingDirFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComponentWorkingDirFactory.java
new file mode 100644
index 000000000000..cc11eca70ed2
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComponentWorkingDirFactory.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import static org.apache.ignite.internal.configuration.IgnitePaths.cmgPath;
+import static org.apache.ignite.internal.configuration.IgnitePaths.metastoragePath;
+import static org.apache.ignite.internal.configuration.IgnitePaths.partitionsPath;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
+import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
+
+/**
+ * Micronaut factory for component working directories.
+ */
+@Factory
+public class ComponentWorkingDirFactory {
+    /** Creates the partitions working directory. */
+    @Singleton
+    @Named("partitions")
+    public ComponentWorkingDir partitionsWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
+        return partitionsPath(systemConfiguration, nodeIdentity.workDir());
+    }
+
+    /** Creates the metastorage working directory. */
+    @Singleton
+    @Named("metastorage")
+    public ComponentWorkingDir metastorageWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
+        return metastoragePath(systemConfiguration, nodeIdentity.workDir());
+    }
+
+    /** Creates the CMG working directory. */
+    @Singleton
+    @Named("cmg")
+    public ComponentWorkingDir cmgWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
+        return cmgPath(systemConfiguration, nodeIdentity.workDir());
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
new file mode 100644
index 000000000000..ec49f9918ab4
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
+import org.apache.ignite.internal.compute.configuration.ComputeExtensionConfiguration;
+import org.apache.ignite.internal.compute.executor.ComputeExecutorImpl;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.deployunit.DeploymentManagerImpl;
+import org.apache.ignite.internal.deployunit.DeploymentUnitAccessor;
+import org.apache.ignite.internal.deployunit.configuration.DeploymentConfiguration;
+import org.apache.ignite.internal.deployunit.configuration.DeploymentExtensionConfiguration;
+import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
+import org.apache.ignite.internal.network.ClusterService;
+
+/**
+ * Micronaut factory for compute and deployment components.
+ */
+@Factory
+public class ComputeFactory {
+    /** Creates the compute configuration from the node config registry. */
+    @Singleton
+    public ComputeConfiguration computeConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(ComputeExtensionConfiguration.KEY).compute();
+    }
+
+    /** Creates the deployment configuration from the node config registry. */
+    @Singleton
+    public DeploymentConfiguration deploymentConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(DeploymentExtensionConfiguration.KEY).deployment();
+    }
+
+    /** Creates the deployment manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(3000)
+    public DeploymentManagerImpl deploymentManager(
+            ClusterService clusterService,
+            DeploymentUnitStoreImpl deploymentUnitStore,
+            LogicalTopologyService logicalTopologyService,
+            NodeIdentity nodeIdentity,
+            DeploymentConfiguration deploymentConfiguration,
+            ClusterManagementGroupManager cmgManager,
+            ComputeExecutorImpl computeExecutor
+    ) {
+        return new DeploymentManagerImpl(
+                clusterService,
+                deploymentUnitStore,
+                logicalTopologyService,
+                nodeIdentity.workDir(),
+                deploymentConfiguration,
+                cmgManager,
+                nodeIdentity.nodeName(),
+                computeExecutor::onUnitRemoving
+        );
+    }
+
+    /** Exposes the deployment unit accessor from the deployment manager. */
+    @Singleton
+    public DeploymentUnitAccessor deploymentUnitAccessor(DeploymentManagerImpl deploymentManager) {
+        return deploymentManager.deploymentUnitAccessor();
+    }
+
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
new file mode 100644
index 000000000000..bdfa2de0a01f
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import static org.apache.ignite.internal.distributionzones.rebalance.RebalanceUtil.pendingPartAssignmentsQueueKey;
+import static org.apache.ignite.internal.distributionzones.rebalance.ZoneRebalanceUtil.zonePartitionStableAssignments;
+
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.ServiceLoader;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
+import org.apache.ignite.internal.catalog.CatalogManager;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.LongJvmPauseDetector;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.ClockService;
+import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.hlc.HybridTimestampTracker;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.partition.replicator.network.PartitionReplicationMessageGroup;
+import org.apache.ignite.internal.partition.replicator.schema.CatalogValidationSchemasSource;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
+import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
+import org.apache.ignite.internal.raft.RaftManager;
+import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
+import org.apache.ignite.internal.raft.storage.LogStorageManager;
+import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
+import org.apache.ignite.internal.replicator.ReplicaManager;
+import org.apache.ignite.internal.replicator.TablePartitionId;
+import org.apache.ignite.internal.replicator.VersionedAssignments;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
+import org.apache.ignite.internal.schema.SchemaSyncService;
+import org.apache.ignite.internal.storage.DataStorageManager;
+import org.apache.ignite.internal.storage.DataStorageModule;
+import org.apache.ignite.internal.storage.DataStorageModules;
+import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
+import org.apache.ignite.internal.storage.engine.StorageEngine;
+import org.apache.ignite.internal.table.distributed.raft.PartitionSafeTimeValidator;
+import org.apache.ignite.internal.table.distributed.schema.ThreadLocalPartitionCommandsMarshaller;
+import org.apache.ignite.internal.tx.message.TxMessageGroup;
+
+/**
+ * Micronaut factory for data path components.
+ */
+@Factory
+public class DataPathFactory {
+    /** Creates the observable hybrid timestamp tracker. */
+    @Singleton
+    public HybridTimestampTracker hybridTimestampTracker() {
+        return HybridTimestampTracker.atomicTracker(null);
+    }
+
+    /** Creates the replica manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1500)
+    public ReplicaManager replicaManager(
+            NodeIdentity nodeIdentity,
+            ClusterService clusterService,
+            ClusterManagementGroupManager cmgManager,
+            MetaStorageManager metaStorageManager,
+            ClockService clockService,
+            PlacementDriver placementDriver,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
+            ReplicationConfiguration replicationConfiguration,
+            FailureManager failureManager,
+            CatalogValidationSchemasSource validationSchemasSource,
+            CatalogManager catalogManager,
+            SchemaSyncService schemaSyncService,
+            TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
+            RaftManager raftManager,
+            @Named("partitions") RaftGroupOptionsConfigurer partitionRaftConfigurer,
+            VolatileLogStorageManagerCreator volatileLogStorageManagerCreator,
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
+    ) {
+        return new ReplicaManager(
+                nodeIdentity.nodeName(),
+                clusterService,
+                cmgManager,
+                groupId -> zonePartitionStableAssignments(metaStorageManager, groupId),
+                clockService,
+                Set.of(
+                        PartitionReplicationMessageGroup.class,
+                        TxMessageGroup.class
+                ),
+                placementDriver,
+                partitionOperationsExecutor,
+                () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
+                failureManager,
+                new ThreadLocalPartitionCommandsMarshaller(
+                        clusterService.serializationRegistry()
+                ),
+                new PartitionSafeTimeValidator(validationSchemasSource, catalogManager, schemaSyncService),
+                topologyAwareRaftGroupServiceFactory,
+                raftManager,
+                partitionRaftConfigurer,
+                volatileLogStorageManagerCreator,
+                tableIoExecutor,
+                replicaGrpId -> metaStorageManager.get(
+                        pendingPartAssignmentsQueueKey((TablePartitionId) replicaGrpId)
+                ).thenApply(entry -> new VersionedAssignments(
+                        entry.value(), entry.revision()
+                )),
+                commonScheduler
+        );
+    }
+
+    /** Creates the data storage manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1800)
+    public DataStorageManager dataStorageManager(
+            NodeIdentity nodeIdentity,
+            MetricManager metricManager,
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir,
+            @Named("longJvmPauseDetector") Provider<LongJvmPauseDetector> longJvmPauseDetector,
+            FailureManager failureManager,
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            HybridClock clock,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
+            StorageConfiguration storageConfiguration
+    ) {
+        DataStorageModules dataStorageModules = new DataStorageModules(
+                ServiceLoader.load(DataStorageModule.class, nodeIdentity.serviceProviderClassLoader())
+        );
+
+        Path storagePath = partitionsWorkDir.dbPath();
+
+        Map<String, StorageEngine> storageEngines = dataStorageModules.createStorageEngines(
+                nodeIdentity.nodeName(),
+                metricManager,
+                nodeConfigRegistry,
+                storagePath,
+                longJvmPauseDetector.get(),
+                failureManager,
+                partitionsLogStorageManager.logSyncer(),
+                clock,
+                commonScheduler
+        );
+
+        return new DataStorageManager(storageEngines, storageConfiguration);
+    }
+
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/EventLogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/EventLogFactory.java
new file mode 100644
index 000000000000..2591805b8c9b
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/EventLogFactory.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
+import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
+
+/**
+ * Micronaut factory for the event log component.
+ */
+@Factory
+public class EventLogFactory {
+    /** Creates the event log. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(3500)
+    public EventLogImpl eventLog(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry,
+            Provider<ClusterManagementGroupManager> cmgManagerProvider,
+            NodeIdentity nodeIdentity
+    ) {
+        return new EventLogImpl(
+                clusterConfigRegistry.getConfiguration(EventLogExtensionConfiguration.KEY).eventlog(),
+                () -> cmgManagerProvider.get().clusterState().join().clusterTag().clusterId(),
+                nodeIdentity.nodeName()
+        );
+    }
+
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
new file mode 100644
index 000000000000..eca41d999f34
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
+import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
+import org.apache.ignite.internal.configuration.storage.LocalFileConfigurationStorage;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
+
+/**
+ * Micronaut factory that produces local (node) configuration beans.
+ *
+ * <p>These form the configuration chain:
+ * {@link ConfigurationModules} → {@link ConfigurationTreeGenerator} → {@link LocalFileConfigurationStorage}
+ * → {@link ConfigurationValidator} → {@link ConfigurationRegistry}.
+ */
+@Factory
+public class IgniteConfigurationFactory {
+    private final NodeIdentity nodeIdentity;
+
+    private final ConfigurationModules modules;
+
+    /** Constructor. */
+    public IgniteConfigurationFactory(NodeIdentity nodeIdentity, ConfigurationModules modules) {
+        this.nodeIdentity = nodeIdentity;
+        this.modules = modules;
+    }
+
+    /** Creates the tree generator for local configuration schemas. */
+    @Singleton
+    @Named("local")
+    public ConfigurationTreeGenerator localConfigurationTreeGenerator() {
+        return new ConfigurationTreeGenerator(
+                modules.local().rootKeys(),
+                modules.local().schemaExtensions(),
+                modules.local().polymorphicSchemaExtensions()
+        );
+    }
+
+    /** Creates the file-based storage for local configuration. */
+    @Singleton
+    public LocalFileConfigurationStorage localFileConfigurationStorage(
+            @Named("local") ConfigurationTreeGenerator generator
+    ) {
+        return new LocalFileConfigurationStorage(
+                nodeIdentity.nodeName(),
+                nodeIdentity.configPath(),
+                generator,
+                modules.local()
+        );
+    }
+
+    /** Creates the validator for local configuration. */
+    @Singleton
+    @Named("local")
+    public ConfigurationValidator localConfigurationValidator(
+            @Named("local") ConfigurationTreeGenerator generator
+    ) {
+        return ConfigurationValidatorImpl.withDefaultValidators(generator, modules.local().validators());
+    }
+
+    /** Creates the local (node) configuration registry. */
+    @Singleton
+    @Named("nodeConfig")
+    public ConfigurationRegistry nodeConfigRegistry(
+            LocalFileConfigurationStorage storage,
+            @Named("local") ConfigurationTreeGenerator generator,
+            @Named("local") ConfigurationValidator validator
+    ) {
+        return ConfigurationRegistryImpl.create(modules.local(), storage, generator, validator);
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
new file mode 100644
index 000000000000..ba9fac4d4431
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import static org.apache.ignite.internal.configuration.IgnitePaths.vaultPath;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.vault.VaultService;
+import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
+
+/**
+ * Micronaut factory that produces infrastructure beans from seed singletons registered in the DI context.
+ */
+@Factory
+public class IgniteNodeSeedFactory {
+    /** Creates the persistent vault service backed by the node's work directory. */
+    @Singleton
+    public VaultService vaultService(NodeIdentity nodeIdentity) {
+        return new PersistentVaultService(vaultPath(nodeIdentity.workDir()));
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
new file mode 100644
index 000000000000..ba58bc43a407
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
+import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
+import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
+import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
+import org.apache.ignite.internal.replicator.configuration.ReplicationExtensionConfiguration;
+import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
+import org.apache.ignite.internal.sql.configuration.distributed.SqlDistributedConfiguration;
+import org.apache.ignite.internal.sql.configuration.local.SqlLocalConfiguration;
+import org.apache.ignite.internal.sql.configuration.local.SqlNodeExtensionConfiguration;
+
+/**
+ * Micronaut factory for MetaStorage, cluster configuration, and SQL configuration components.
+ */
+@Factory
+public class MetaStorageFactory {
+    /** Creates the cluster (distributed) configuration registry. */
+    @Singleton
+    @Named("clusterConfig")
+    public ConfigurationRegistry clusterConfigRegistry(
+            ConfigurationModules modules,
+            DistributedConfigurationStorage cfgStorage,
+            @Named("distributed") ConfigurationTreeGenerator generator,
+            @Named("distributed") ConfigurationValidator validator
+    ) {
+        return ConfigurationRegistryImpl.create(modules.distributed(), cfgStorage, generator, validator);
+    }
+
+    /** Creates the schema synchronization configuration from the cluster config registry. */
+    @Singleton
+    public SchemaSynchronizationConfiguration schemaSynchronizationConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry
+                .getConfiguration(SchemaSynchronizationExtensionConfiguration.KEY).schemaSync();
+    }
+
+    /** Creates the replication configuration from the cluster config registry. */
+    @Singleton
+    public ReplicationConfiguration replicationConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry
+                .getConfiguration(ReplicationExtensionConfiguration.KEY).replication();
+    }
+
+    /** Creates the SQL distributed configuration from the cluster config registry. */
+    @Singleton
+    public SqlDistributedConfiguration sqlDistributedConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(SqlClusterExtensionConfiguration.KEY).sql();
+    }
+
+    /** Creates the SQL local configuration from the node config registry. */
+    @Singleton
+    public SqlLocalConfiguration sqlLocalConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(SqlNodeExtensionConfiguration.KEY).sql();
+    }
+}
+
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
new file mode 100644
index 000000000000..f0961477b677
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.IgniteServer;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
+import org.apache.ignite.internal.configuration.SystemLocalExtensionConfiguration;
+import org.apache.ignite.internal.failure.NodeStopper;
+import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
+import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
+import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
+import org.apache.ignite.internal.network.configuration.NetworkExtensionConfiguration;
+import org.apache.ignite.internal.worker.configuration.CriticalWorkersConfiguration;
+
+/**
+ * Micronaut factory for network and infrastructure components.
+ */
+@Factory
+public class NetworkComponentsFactory {
+    /** Creates the network configuration from the node config registry. */
+    @Singleton
+    public NetworkConfiguration networkConfiguration(@Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry) {
+        return nodeConfigRegistry.getConfiguration(NetworkExtensionConfiguration.KEY).network();
+    }
+
+    /** Creates the failure processor configuration from the node config registry. */
+    @Singleton
+    public FailureProcessorConfiguration failureProcessorConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(FailureProcessorExtensionConfiguration.KEY).failureHandler();
+    }
+
+    /** Creates the system local configuration from the node config registry. */
+    @Singleton
+    public SystemLocalConfiguration systemLocalConfiguration(@Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry) {
+        return nodeConfigRegistry.getConfiguration(SystemLocalExtensionConfiguration.KEY).system();
+    }
+
+    /** Creates the critical workers configuration from the system local config. */
+    @Singleton
+    public CriticalWorkersConfiguration criticalWorkersConfiguration(SystemLocalConfiguration systemConfiguration) {
+        return systemConfiguration.criticalWorkers();
+    }
+
+    /** Creates the node stopper. */
+    @Singleton
+    public NodeStopper nodeStopper(IgniteServer igniteServer) {
+        return igniteServer::shutdown;
+    }
+
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java
new file mode 100644
index 000000000000..01176fab69fc
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java
@@ -0,0 +1,273 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.client.handler.ClientHandlerModule;
+import org.apache.ignite.internal.app.NodePropertiesImpl;
+import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.catalog.DataNodesAwarePartitionCountCalculator;
+import org.apache.ignite.internal.catalog.PartitionCountCalculatorWrapper;
+import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
+import org.apache.ignite.internal.cluster.management.NodeAttributesCollector;
+import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.compute.ComputeComponentImpl;
+import org.apache.ignite.internal.compute.IgniteComputeInternal;
+import org.apache.ignite.internal.compute.executor.ComputeExecutorImpl;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
+import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
+import org.apache.ignite.internal.metastorage.cache.IdempotentCacheVacuumizer;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.metrics.MetricManagerImpl;
+import org.apache.ignite.internal.metrics.configuration.MetricExtensionConfiguration;
+import org.apache.ignite.internal.metrics.sources.ClockServiceMetricSource;
+import org.apache.ignite.internal.metrics.sources.JvmMetricSource;
+import org.apache.ignite.internal.metrics.sources.OsMetricSource;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.LogicalTopologyEventsListener;
+import org.apache.ignite.internal.raft.Loza;
+import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
+import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
+import org.apache.ignite.internal.sql.engine.api.kill.CancellableOperationType;
+import org.apache.ignite.internal.sql.engine.api.kill.OperationKillHandler;
+import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
+import org.apache.ignite.internal.system.CpuInformationProvider;
+import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
+import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
+import org.apache.ignite.internal.table.distributed.schema.CheckCatalogVersionOnActionRequest;
+import org.apache.ignite.internal.table.distributed.schema.CheckCatalogVersionOnAppendEntries;
+import org.apache.ignite.internal.tx.TxManager;
+import org.apache.ignite.internal.tx.impl.TxManagerImpl;
+
+/**
+ * Performs post-construction wiring that cannot be expressed as constructor injection.
+ * This includes listener registrations, interceptor setups, and cross-component hookups.
+ */
+@Singleton
+public class PostConstructionWiring {
+    private final MetricManagerImpl metricManager;
+    private final ClockServiceMetricSource clockServiceMetricSource;
+    private final MetaStorageManagerImpl metaStorageManager;
+    private final CatalogManagerImpl catalogManager;
+    private final IdempotentCacheVacuumizer idempotentCacheVacuumizer;
+    private final CatalogCompactionRunner catalogCompactionRunner;
+    private final SchemaSafeTimeTrackerImpl schemaSafeTimeTracker;
+    private final Loza raftManager;
+    private final LogicalTopologyImpl logicalTopology;
+    private final ClusterService clusterService;
+    private final NodeAttributesCollector nodeAttributesCollector;
+    private final NodePropertiesImpl nodeProperties;
+    private final SystemViewManagerImpl systemViewManager;
+    private final TxManagerImpl txManager;
+    private final SqlQueryProcessor sqlQueryProcessor;
+    private final ComputeComponentImpl computeComponent;
+    private final IgniteComputeInternal compute;
+    private final KillCommandHandler killCommandHandler;
+    private final ComputeExecutorImpl computeExecutor;
+    private final ClientHandlerModule clientHandlerModule;
+    private final PartitionModificationCounterFactory partitionModificationCounterFactory;
+    private final SystemDistributedConfiguration systemDistributedConfiguration;
+    private final ConfigurationRegistry clusterConfigRegistry;
+    private final DistributionZoneManager distributionZoneManager;
+    private final CpuInformationProvider cpuInformationProvider;
+    private final PartitionCountCalculatorWrapper partitionCountCalculatorWrapper;
+
+    /** Constructor. */
+    public PostConstructionWiring(
+            MetricManagerImpl metricManager,
+            ClockServiceMetricSource clockServiceMetricSource,
+            MetaStorageManagerImpl metaStorageManager,
+            CatalogManagerImpl catalogManager,
+            IdempotentCacheVacuumizer idempotentCacheVacuumizer,
+            CatalogCompactionRunner catalogCompactionRunner,
+            SchemaSafeTimeTrackerImpl schemaSafeTimeTracker,
+            Loza raftManager,
+            LogicalTopologyImpl logicalTopology,
+            ClusterService clusterService,
+            NodeAttributesCollector nodeAttributesCollector,
+            NodePropertiesImpl nodeProperties,
+            SystemViewManagerImpl systemViewManager,
+            TxManagerImpl txManager,
+            SqlQueryProcessor sqlQueryProcessor,
+            ComputeComponentImpl computeComponent,
+            IgniteComputeInternal compute,
+            KillCommandHandler killCommandHandler,
+            ComputeExecutorImpl computeExecutor,
+            ClientHandlerModule clientHandlerModule,
+            PartitionModificationCounterFactory partitionModificationCounterFactory,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry,
+            DistributionZoneManager distributionZoneManager,
+            CpuInformationProvider cpuInformationProvider,
+            PartitionCountCalculatorWrapper partitionCountCalculatorWrapper
+    ) {
+        this.metricManager = metricManager;
+        this.clockServiceMetricSource = clockServiceMetricSource;
+        this.metaStorageManager = metaStorageManager;
+        this.catalogManager = catalogManager;
+        this.idempotentCacheVacuumizer = idempotentCacheVacuumizer;
+        this.catalogCompactionRunner = catalogCompactionRunner;
+        this.schemaSafeTimeTracker = schemaSafeTimeTracker;
+        this.raftManager = raftManager;
+        this.logicalTopology = logicalTopology;
+        this.clusterService = clusterService;
+        this.nodeAttributesCollector = nodeAttributesCollector;
+        this.nodeProperties = nodeProperties;
+        this.systemViewManager = systemViewManager;
+        this.txManager = txManager;
+        this.sqlQueryProcessor = sqlQueryProcessor;
+        this.computeComponent = computeComponent;
+        this.compute = compute;
+        this.killCommandHandler = killCommandHandler;
+        this.computeExecutor = computeExecutor;
+        this.clientHandlerModule = clientHandlerModule;
+        this.partitionModificationCounterFactory = partitionModificationCounterFactory;
+        this.systemDistributedConfiguration = systemDistributedConfiguration;
+        this.clusterConfigRegistry = clusterConfigRegistry;
+        this.distributionZoneManager = distributionZoneManager;
+        this.cpuInformationProvider = cpuInformationProvider;
+        this.partitionCountCalculatorWrapper = partitionCountCalculatorWrapper;
+    }
+
+    /**
+     * Performs wiring needed before Phase 1 start.
+     * This includes metric source registration and metric configuration.
+     */
+    public void wirePhase1() {
+        JvmMetricSource jvmMetrics = new JvmMetricSource();
+        metricManager.registerSource(jvmMetrics);
+        metricManager.enable(jvmMetrics);
+
+        OsMetricSource osMetrics = new OsMetricSource();
+        metricManager.registerSource(osMetrics);
+        metricManager.enable(osMetrics);
+
+        metricManager.registerSource(clockServiceMetricSource);
+        metricManager.enable(clockServiceMetricSource);
+
+        partitionModificationCounterFactory.start();
+    }
+
+    /**
+     * Performs wiring needed before Phase 2 start.
+     * This includes MetaStorage listeners, Raft interceptors, system view registrations, and kill handlers.
+     */
+    public void wirePhase2() {
+        // Wire the data-nodes-aware partition count calculator into the wrapper.
+        partitionCountCalculatorWrapper.setPartitionCountCalculator(
+                new DataNodesAwarePartitionCountCalculator(
+                        distributionZoneManager::estimatedDataNodesCount,
+                        cpuInformationProvider
+                )
+        );
+
+        // MetaStorage configuration and listeners.
+        metaStorageManager.configure(systemDistributedConfiguration);
+        metricManager.configure(clusterConfigRegistry.getConfiguration(MetricExtensionConfiguration.KEY).metrics());
+        metaStorageManager.addElectionListener(idempotentCacheVacuumizer);
+        metaStorageManager.addElectionListener(catalogCompactionRunner::updateCoordinator);
+        metaStorageManager.registerNotificationEnqueuedListener(schemaSafeTimeTracker);
+
+        // Raft interceptors.
+        raftManager.appendEntriesRequestInterceptor(new CheckCatalogVersionOnAppendEntries(catalogManager));
+        raftManager.actionRequestInterceptor(new CheckCatalogVersionOnActionRequest(catalogManager));
+
+        // Node attributes.
+        nodeAttributesCollector.register(nodeProperties);
+        nodeAttributesCollector.register(systemViewManager);
+
+        // Logical topology listener for joined nodes.
+        logicalTopology.addEventListener(logicalTopologyJoinedNodesListener(clusterService.topologyService()));
+        logicalTopology.addEventListener(systemViewManager);
+
+        // System view registrations.
+        systemViewManager.register(catalogManager);
+        systemViewManager.register(txManager);
+        systemViewManager.register(sqlQueryProcessor);
+        systemViewManager.register(computeComponent);
+
+        // Kill command handlers.
+        killCommandHandler.register(transactionKillHandler(txManager));
+        killCommandHandler.register(computeKillHandler(compute));
+
+        // Compute <-> client handler bridge.
+        computeExecutor.setPlatformComputeTransport(clientHandlerModule);
+    }
+
+    private static LogicalTopologyEventListener logicalTopologyJoinedNodesListener(LogicalTopologyEventsListener listener) {
+        return new LogicalTopologyEventListener() {
+            @Override
+            public void onNodeJoined(LogicalNode joinedNode, LogicalTopologySnapshot newTopology) {
+                listener.onJoined(joinedNode, newTopology.version());
+            }
+
+            @Override
+            public void onNodeLeft(LogicalNode leftNode, LogicalTopologySnapshot newTopology) {
+                listener.onLeft(leftNode, newTopology.version());
+            }
+        };
+    }
+
+    private static OperationKillHandler computeKillHandler(IgniteComputeInternal compute) {
+        return new OperationKillHandler() {
+            @Override
+            public CompletableFuture<Boolean> cancelAsync(String operationId) {
+                UUID jobId = UUID.fromString(operationId);
+                return compute.cancelAsync(jobId)
+                        .thenApply(res -> res != null ? res : Boolean.FALSE);
+            }
+
+            @Override
+            public boolean local() {
+                return false;
+            }
+
+            @Override
+            public CancellableOperationType type() {
+                return CancellableOperationType.COMPUTE;
+            }
+        };
+    }
+
+    private static OperationKillHandler transactionKillHandler(TxManager txManager) {
+        return new OperationKillHandler() {
+            @Override
+            public CompletableFuture<Boolean> cancelAsync(String operationId) {
+                UUID transactionId = UUID.fromString(operationId);
+                return txManager.kill(transactionId);
+            }
+
+            @Override
+            public boolean local() {
+                return true;
+            }
+
+            @Override
+            public CancellableOperationType type() {
+                return CancellableOperationType.TRANSACTION;
+            }
+        };
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
new file mode 100644
index 000000000000..0be5935d5fd0
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
@@ -0,0 +1,178 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import java.nio.file.Path;
+import java.util.Map;
+import org.apache.ignite.internal.cluster.management.CmgGroupId;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.LogSyncer;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
+import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
+import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
+import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
+import org.apache.ignite.internal.raft.configuration.RaftExtensionConfiguration;
+import org.apache.ignite.internal.raft.server.impl.GroupStoragesContextResolver;
+import org.apache.ignite.internal.raft.storage.LogStorageManager;
+import org.apache.ignite.internal.raft.util.SharedLogStorageManagerUtils;
+import org.apache.ignite.internal.replicator.PartitionGroupId;
+
+/**
+ * Micronaut factory for Raft infrastructure components.
+ */
+@Factory
+public class RaftFactory {
+    /** Used for durable destruction purposes. */
+    private static final String PARTITION_GROUP_NAME = "partition";
+
+    /** Creates the Raft configuration from the node config registry. */
+    @Singleton
+    public RaftConfiguration raftConfiguration(@Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry) {
+        return nodeConfigRegistry.getConfiguration(RaftExtensionConfiguration.KEY).raft();
+    }
+
+    /** Creates the partitions log storage manager. */
+    @Singleton
+    @Named("partitions")
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1500)
+    public LogStorageManager partitionsLogStorageManager(
+            NodeIdentity nodeIdentity,
+            RaftConfiguration raftConfiguration,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir
+    ) {
+        return SharedLogStorageManagerUtils.create(
+                "table data log",
+                nodeIdentity.nodeName(),
+                partitionsWorkDir.raftLogPath(),
+                raftConfiguration.fsync().value()
+        );
+    }
+
+    /** Creates the metastorage log storage manager. */
+    @Singleton
+    @Named("metastorage")
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1600)
+    public LogStorageManager msLogStorageManager(
+            NodeIdentity nodeIdentity,
+            @Named("metastorage") ComponentWorkingDir metastorageWorkDir
+    ) {
+        return SharedLogStorageManagerUtils.create(
+                "meta-storage log",
+                nodeIdentity.nodeName(),
+                metastorageWorkDir.raftLogPath(),
+                true
+        );
+    }
+
+    /** Creates the CMG log storage manager. */
+    @Singleton
+    @Named("cmg")
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1700)
+    public LogStorageManager cmgLogStorageManager(
+            NodeIdentity nodeIdentity,
+            @Named("cmg") ComponentWorkingDir cmgWorkDir
+    ) {
+        return SharedLogStorageManagerUtils.create(
+                "cluster-management-group log",
+                nodeIdentity.nodeName(),
+                cmgWorkDir.raftLogPath(),
+                true
+        );
+    }
+
+    /** Exposes the partitions log syncer as a named bean. */
+    @Singleton
+    @Named("partitions")
+    public LogSyncer partitionsLogSyncer(
+            @Named("partitions") LogStorageManager partitionsLogStorageManager
+    ) {
+        return partitionsLogStorageManager.logSyncer();
+    }
+
+    /** Creates the partitions Raft group options configurer. */
+    @Singleton
+    @Named("partitions")
+    public RaftGroupOptionsConfigurer partitionRaftConfigurer(
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir
+    ) {
+        return RaftGroupOptionsConfigHelper.configureProperties(partitionsLogStorageManager, partitionsWorkDir.metaPath());
+    }
+
+    /** Creates the metastorage Raft group options configurer. */
+    @Singleton
+    @Named("metastorage")
+    public RaftGroupOptionsConfigurer msRaftConfigurer(
+            @Named("metastorage") LogStorageManager msLogStorageManager,
+            @Named("metastorage") ComponentWorkingDir metastorageWorkDir
+    ) {
+        return RaftGroupOptionsConfigHelper.configureProperties(msLogStorageManager, metastorageWorkDir.metaPath());
+    }
+
+    /** Creates the CMG Raft group options configurer. */
+    @Singleton
+    @Named("cmg")
+    public RaftGroupOptionsConfigurer cmgRaftConfigurer(
+            @Named("cmg") LogStorageManager cmgLogStorageManager,
+            @Named("cmg") ComponentWorkingDir cmgWorkDir
+    ) {
+        return RaftGroupOptionsConfigHelper.configureProperties(cmgLogStorageManager, cmgWorkDir.metaPath());
+    }
+
+    /** Creates the group storages context resolver. */
+    @Singleton
+    public GroupStoragesContextResolver groupStoragesContextResolver(
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            @Named("metastorage") LogStorageManager msLogStorageManager,
+            @Named("cmg") LogStorageManager cmgLogStorageManager,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir,
+            @Named("metastorage") ComponentWorkingDir metastorageWorkDir,
+            @Named("cmg") ComponentWorkingDir cmgWorkDir
+    ) {
+        Map<String, LogStorageManager> logStorageManagerByGroupName = Map.of(
+                PARTITION_GROUP_NAME, partitionsLogStorageManager,
+                MetastorageGroupId.INSTANCE.toString(), msLogStorageManager,
+                CmgGroupId.INSTANCE.toString(), cmgLogStorageManager
+        );
+
+        Map<String, Path> serverDataPathByGroupName = Map.of(
+                PARTITION_GROUP_NAME, partitionsWorkDir.metaPath(),
+                MetastorageGroupId.INSTANCE.toString(), metastorageWorkDir.metaPath(),
+                CmgGroupId.INSTANCE.toString(), cmgWorkDir.metaPath()
+        );
+
+        return new GroupStoragesContextResolver(
+                replicationGroupId -> replicationGroupId instanceof PartitionGroupId
+                        ? PARTITION_GROUP_NAME : replicationGroupId.toString(),
+                serverDataPathByGroupName,
+                logStorageManagerByGroupName
+        );
+    }
+
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
new file mode 100644
index 000000000000..f76f6d527d31
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import java.util.concurrent.ExecutorService;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
+import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
+import org.apache.ignite.internal.network.MessagingService;
+import org.apache.ignite.internal.network.wrapper.JumpToExecutorByConsistentIdAfterSend;
+import org.apache.ignite.internal.schema.configuration.GcConfiguration;
+import org.apache.ignite.internal.schema.configuration.GcExtensionConfiguration;
+import org.apache.ignite.internal.schema.configuration.LowWatermarkConfiguration;
+import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
+import org.apache.ignite.internal.tx.configuration.TransactionExtensionConfiguration;
+
+/**
+ * Micronaut factory for transaction-related components.
+ */
+@Factory
+public class TransactionFactory {
+    /** Creates the transaction configuration from the cluster config registry. */
+    @Singleton
+    public TransactionConfiguration transactionConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(TransactionExtensionConfiguration.KEY).transaction();
+    }
+
+    /** Creates the system distributed configuration from the cluster config registry. */
+    @Singleton
+    public SystemDistributedConfiguration systemDistributedConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(SystemDistributedExtensionConfiguration.KEY).system();
+    }
+
+    /** Creates the GC configuration from the cluster config registry. */
+    @Singleton
+    public GcConfiguration gcConfiguration(@Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry) {
+        return clusterConfigRegistry.getConfiguration(GcExtensionConfiguration.KEY).gc();
+    }
+
+    /** Creates the low watermark configuration from the GC config. */
+    @Singleton
+    public LowWatermarkConfiguration lowWatermarkConfiguration(GcConfiguration gcConfiguration) {
+        return gcConfiguration.lowWatermark();
+    }
+
+    /** Creates the messaging service wrapper that jumps to the storage operations thread pool. */
+    @Singleton
+    @Named("storageOperations")
+    public MessagingService storageOperationsMessagingService(
+            @Named("clusterMessaging") MessagingService clusterMessagingService,
+            NodeIdentity nodeIdentity,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor
+    ) {
+        return new JumpToExecutorByConsistentIdAfterSend(
+                clusterMessagingService,
+                nodeIdentity.nodeName(),
+                message -> partitionOperationsExecutor
+        );
+    }
+
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java b/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java
index 32749d0b80ed..6cd114295663 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java
@@ -17,11 +17,14 @@
 
 package org.apache.ignite.internal.catalog;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import org.apache.ignite.internal.catalog.commands.CatalogUtils;
 
 /**
  * Wrapper that allows to apply and use different partition count computing approaches.
  */
+@Singleton
 public final class PartitionCountCalculatorWrapper implements PartitionCountCalculator {
     /** Wrapped delegate to compute partition count. */
     private volatile PartitionCountCalculator delegate;
@@ -35,6 +38,7 @@ public PartitionCountCalculatorWrapper(PartitionCountCalculator delegate) {
      * Constructor that uses {@link PartitionCountCalculator#staticPartitionCountCalculator} with
      * {@link CatalogUtils#DEFAULT_PARTITION_COUNT} as static calculation result.
      * */
+    @Inject
     public PartitionCountCalculatorWrapper() {
         this(PartitionCountCalculator.staticPartitionCountCalculator(CatalogUtils.DEFAULT_PARTITION_COUNT));
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/JdbcPortProviderImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/configuration/JdbcPortProviderImpl.java
index f9d33cec2d33..780bbea0ec57 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/JdbcPortProviderImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/configuration/JdbcPortProviderImpl.java
@@ -17,17 +17,20 @@
 
 package org.apache.ignite.internal.configuration;
 
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import org.apache.ignite.client.handler.configuration.ClientConnectorExtensionConfiguration;
 import org.apache.ignite.internal.rest.node.JdbcPortProvider;
 
 /**
  * Provider of client port from node configuration.
  */
+@Singleton
 public class JdbcPortProviderImpl implements JdbcPortProvider {
 
     private final ConfigurationRegistry configurationRegistry;
 
-    public JdbcPortProviderImpl(ConfigurationRegistry configurationRegistry) {
+    public JdbcPortProviderImpl(@Named("nodeConfig") ConfigurationRegistry configurationRegistry) {
         this.configurationRegistry = configurationRegistry;
     }
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/metrics/logstorage/LogStorageMetrics.java b/modules/runner/src/main/java/org/apache/ignite/internal/metrics/logstorage/LogStorageMetrics.java
index f5f073b26cf8..c0f5b286d523 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/metrics/logstorage/LogStorageMetrics.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/metrics/logstorage/LogStorageMetrics.java
@@ -22,10 +22,17 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
@@ -39,6 +46,9 @@
 /**
  * Component that collects metrics about log storages.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1400)
 public class LogStorageMetrics implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(LogStorageMetrics.class);
 
@@ -60,6 +70,20 @@ public class LogStorageMetrics implements IgniteComponent {
     private volatile ScheduledExecutorService executorService;
     private volatile ScheduledFuture<?> taskFuture;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public LogStorageMetrics(
+            NodeIdentity nodeIdentity,
+            MetricManager metricManager,
+            @Named("cmg") LogStorageManager cmgLogStorageManager,
+            @Named("metastorage") LogStorageManager metastorageLogStorageManager,
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            VolatileLogStorageManagerCreator volatileLogStorageManagerCreator
+    ) {
+        this(nodeIdentity.nodeName(), metricManager, cmgLogStorageManager, metastorageLogStorageManager,
+                partitionsLogStorageManager, volatileLogStorageManagerCreator);
+    }
+
     /** Constructor. */
     public LogStorageMetrics(
             String nodeName,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/schema/SchemaSafeTimeTrackerImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/schema/SchemaSafeTimeTrackerImpl.java
index f05e79c0adaf..c574d6311ba1 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/schema/SchemaSafeTimeTrackerImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/schema/SchemaSafeTimeTrackerImpl.java
@@ -19,15 +19,21 @@
 
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 import org.apache.ignite.internal.metastorage.Entry;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.metastorage.server.NotificationEnqueuedListener;
 import org.apache.ignite.internal.metastorage.server.time.ClusterTime;
 import org.apache.ignite.internal.util.PendingComparableValuesTracker;
@@ -36,6 +42,9 @@
 /**
  * Default implementation of {@link SchemaSafeTimeTracker}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1900)
 public class SchemaSafeTimeTrackerImpl implements SchemaSafeTimeTracker, IgniteComponent, NotificationEnqueuedListener {
     private final ClusterTime clusterTime;
 
@@ -46,6 +55,14 @@ public class SchemaSafeTimeTrackerImpl implements SchemaSafeTimeTracker, IgniteC
 
     private final Object futureMutex = new Object();
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public SchemaSafeTimeTrackerImpl(MetaStorageManager metaStorageManager) {
+        this(metaStorageManager.clusterTime());
+    }
+
     public SchemaSafeTimeTrackerImpl(ClusterTime clusterTime) {
         this.clusterTime = clusterTime;
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/system/JvmCpuInformationProvider.java b/modules/runner/src/main/java/org/apache/ignite/internal/system/JvmCpuInformationProvider.java
index 912de39c798c..c9dfdd9a1abc 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/system/JvmCpuInformationProvider.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/system/JvmCpuInformationProvider.java
@@ -17,9 +17,12 @@
 
 package org.apache.ignite.internal.system;
 
+import jakarta.inject.Singleton;
+
 /**
  * Provides CPU information based on JVM {@link Runtime} instance.
  */
+@Singleton
 public class JvmCpuInformationProvider implements CpuInformationProvider {
     @Override
     public int availableProcessors() {
diff --git a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/ConfigurationModulesTest.java b/modules/runner/src/test/java/org/apache/ignite/internal/configuration/ConfigurationModulesTest.java
index 43a3467d139e..02aa37546fd1 100644
--- a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/ConfigurationModulesTest.java
+++ b/modules/runner/src/test/java/org/apache/ignite/internal/configuration/ConfigurationModulesTest.java
@@ -68,7 +68,7 @@ void mergesLocalModules() {
         when(moduleA.rootKeys()).thenReturn(Set.of(rootKeyA));
         when(moduleB.rootKeys()).thenReturn(Set.of(rootKeyB));
 
-        var modules = new ConfigurationModules(List.of(moduleA, moduleB, moduleC, moduleD));
+        var modules = new ConfigurationModulesImpl(List.of(moduleA, moduleB, moduleC, moduleD));
 
         assertThat(modules.local().rootKeys(), containsInAnyOrder(rootKeyA, rootKeyB));
     }
@@ -82,7 +82,7 @@ void mergesDistributedModules() {
         when(moduleC.rootKeys()).thenReturn(Set.of(rootKeyC));
         when(moduleD.rootKeys()).thenReturn(Set.of(rootKeyD));
 
-        var modules = new ConfigurationModules(List.of(moduleA, moduleB, moduleC, moduleD));
+        var modules = new ConfigurationModulesImpl(List.of(moduleA, moduleB, moduleC, moduleD));
 
         assertThat(modules.distributed().rootKeys(), containsInAnyOrder(rootKeyC, rootKeyD));
     }
@@ -90,7 +90,7 @@ void mergesDistributedModules() {
     @ParameterizedTest
     @MethodSource("classLoaderSource")
     void createdUsingClassLoader(ClassLoader classLoader) {
-        ConfigurationModules modules = ConfigurationModules.create(classLoader);
+        ConfigurationModules modules = ConfigurationModulesImpl.create(classLoader);
 
         assertThat(modules.local().schemaExtensions().size(), is(greaterThan(0)));
         assertThat(modules.distributed().schemaExtensions().size(), is(greaterThan(0)));
diff --git a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/compatibility/ConfigurationCompatibilityTest.java b/modules/runner/src/test/java/org/apache/ignite/internal/configuration/compatibility/ConfigurationCompatibilityTest.java
index 19a3d698304a..c02d32c706ba 100644
--- a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/compatibility/ConfigurationCompatibilityTest.java
+++ b/modules/runner/src/test/java/org/apache/ignite/internal/configuration/compatibility/ConfigurationCompatibilityTest.java
@@ -38,6 +38,7 @@
 import org.apache.ignite.configuration.ConfigurationModule;
 import org.apache.ignite.configuration.RootKey;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite.internal.configuration.compatibility.framework.ConfigNode;
 import org.apache.ignite.internal.configuration.compatibility.framework.ConfigNodeSerializer;
 import org.apache.ignite.internal.configuration.compatibility.framework.ConfigurationSnapshotManager;
@@ -122,7 +123,7 @@ void testConfigurationCompatibility(String fileName) throws IOException {
     }
 
     static List<ConfigNode> loadCurrentConfiguration() {
-        ConfigurationModules modules = ConfigurationModules.create(ConfigurationCompatibilityTest.class.getClassLoader());
+        ConfigurationModules modules = ConfigurationModulesImpl.create(ConfigurationCompatibilityTest.class.getClassLoader());
 
         ConfigurationModule local = modules.local();
         ConfigurationModule distributed = modules.distributed();
diff --git a/modules/runner/src/testFixtures/java/org/apache/ignite/internal/BaseIgniteRestartTest.java b/modules/runner/src/testFixtures/java/org/apache/ignite/internal/BaseIgniteRestartTest.java
index 6d1e128b3d0b..3143c9c27418 100644
--- a/modules/runner/src/testFixtures/java/org/apache/ignite/internal/BaseIgniteRestartTest.java
+++ b/modules/runner/src/testFixtures/java/org/apache/ignite/internal/BaseIgniteRestartTest.java
@@ -52,6 +52,7 @@
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopology;
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
@@ -232,7 +233,7 @@ private static Set<String> cmgMsNodes(ClusterManagementGroupManager cmgManager)
      * @return Configuration modules.
      */
     public static ConfigurationModules loadConfigurationModules(IgniteLogger log, ClassLoader classLoader) {
-        ConfigurationModules configModules = ConfigurationModules.create(classLoader);
+        ConfigurationModules configModules = ConfigurationModulesImpl.create(classLoader);
 
         if (log.isInfoEnabled()) {
             log.info("Local root keys: {}", configModules.local().rootKeys());
diff --git a/modules/schema/build.gradle b/modules/schema/build.gradle
index 6e22b4fc92c6..dc38447abaea 100644
--- a/modules/schema/build.gradle
+++ b/modules/schema/build.gradle
@@ -25,6 +25,7 @@ description = 'ignite-schema'
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     api project(':ignite-binary-tuple')
     api project(':ignite-marshaller-common')
@@ -38,6 +39,8 @@ dependencies {
     implementation project(':ignite-configuration-root')
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
+    implementation project(':ignite-di')
 
     testAnnotationProcessor project(':ignite-configuration-annotation-processor')
     testAnnotationProcessor libs.jmh.annotation.processor
@@ -61,4 +64,6 @@ dependencies {
     testFixturesImplementation project(':ignite-configuration-api')
     testFixturesImplementation project(':ignite-catalog')
     testFixturesImplementation testFixtures(project(':ignite-core'))
+    testFixturesImplementation project(':ignite-di')
+    testFixturesImplementation libs.micronaut.inject
 }
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java
index cde708250a0f..bb49ff90271a 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java
@@ -25,6 +25,8 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
@@ -39,6 +41,8 @@
 import org.apache.ignite.internal.catalog.events.TableEventParameters;
 import org.apache.ignite.internal.causality.IncrementalVersionedValue;
 import org.apache.ignite.internal.causality.RevisionListenerRegistry;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -52,6 +56,9 @@
 /**
  * This class services management of table schemas.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2000)
 public class SchemaManager implements IgniteComponent {
     /** Busy lock to stop synchronously. */
     private final IgniteSpinBusyLock busyLock = new IgniteSpinBusyLock();
diff --git a/modules/security/build.gradle b/modules/security/build.gradle
index 032453b4ab01..4eb707406bb5 100644
--- a/modules/security/build.gradle
+++ b/modules/security/build.gradle
@@ -31,9 +31,12 @@ dependencies {
     implementation project(':ignite-eventlog')
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
+    implementation project(':ignite-di')
 
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     testAnnotationProcessor project(':ignite-configuration-annotation-processor')
     testImplementation project(':ignite-configuration')
diff --git a/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java b/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java
index 543e9ee19c66..8638dc5dc7e5 100644
--- a/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java
+++ b/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java
@@ -22,6 +22,8 @@
 import static org.apache.ignite.internal.security.authentication.AuthenticationUtils.findBasicProviderName;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
@@ -30,6 +32,8 @@
 import java.util.stream.Collectors;
 import org.apache.ignite.configuration.NamedListView;
 import org.apache.ignite.configuration.notifications.ConfigurationListener;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.event.AbstractEventProducer;
 import org.apache.ignite.internal.eventlog.api.EventLog;
 import org.apache.ignite.internal.eventlog.api.IgniteEventType;
@@ -55,6 +59,9 @@
 /**
  * Implementation of {@link Authenticator}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2850)
 public class AuthenticationManagerImpl
         extends AbstractEventProducer<AuthenticationEvent, AuthenticationEventParameters>
         implements AuthenticationManager {
diff --git a/modules/sql-engine/build.gradle b/modules/sql-engine/build.gradle
index e495f7d54192..6637cc81f60f 100644
--- a/modules/sql-engine/build.gradle
+++ b/modules/sql-engine/build.gradle
@@ -79,9 +79,11 @@ dependencies {
     implementation libs.auto.service.annotations
     implementation libs.jsr305
     implementation libs.guava
+    implementation libs.micronaut.inject
 
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor project(':ignite-configuration-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.value.annotation.processor
     annotationProcessor libs.auto.service
 
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/IgniteSqlImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/IgniteSqlImpl.java
index 958a2b301f32..67e53b771f4f 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/IgniteSqlImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/IgniteSqlImpl.java
@@ -22,7 +22,11 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.EnumSet;
@@ -34,6 +38,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -41,6 +46,8 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Supplier;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -83,6 +90,9 @@
 /**
  * Embedded implementation of the Ignite SQL query facade.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(3100)
 @SuppressWarnings("rawtypes")
 public class IgniteSqlImpl implements IgniteSql, IgniteComponent, Wrapper {
     private static final IgniteLogger LOG = Loggers.forClass(IgniteSqlImpl.class);
@@ -103,6 +113,22 @@ public class IgniteSqlImpl implements IgniteSql, IgniteComponent, Wrapper {
 
     private final Executor commonExecutor;
 
+    /**
+     * Constructor for dependency injection.
+     *
+     * @param queryProcessor Query processor.
+     * @param observableTimestampTracker Tracker of the latest time observed by client.
+     * @param commonScheduler Executor that is used to close cursors when executing a script.
+     */
+    @Inject
+    public IgniteSqlImpl(
+            QueryProcessor queryProcessor,
+            HybridTimestampTracker observableTimestampTracker,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
+    ) {
+        this(queryProcessor, observableTimestampTracker, (Executor) commonScheduler);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
index 6b8a5c175ae4..d33b93258955 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
@@ -27,6 +27,10 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Sql.EXECUTION_CANCELLED_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -39,6 +43,8 @@
 import java.util.function.Supplier;
 import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.eventlog.api.EventLog;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockService;
@@ -128,6 +134,9 @@
 /**
  *  Main implementation of {@link QueryProcessor}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2800)
 public class SqlQueryProcessor implements QueryProcessor, SystemViewProvider {
 
     private static final int PARSED_RESULT_CACHE_SIZE = 10_000;
@@ -210,6 +219,7 @@ public class SqlQueryProcessor implements QueryProcessor, SystemViewProvider {
     private final SqlExpressionFactory expressionFactory;
 
     /** Constructor. */
+    @Inject
     public SqlQueryProcessor(
             ClusterService clusterSrvc,
             LogicalTopologyService logicalTopologyService,
@@ -228,7 +238,7 @@ public SqlQueryProcessor(
             TransactionInflights transactionInflights,
             TxManager txManager,
             LowWatermark lowWaterMark,
-            ScheduledExecutorService commonScheduler,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             KillCommandHandler killCommandHandler,
             EventLog eventLog
     ) {
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/kill/KillCommandHandler.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/kill/KillCommandHandler.java
index d4f2fc432197..ebe0a31694c8 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/kill/KillCommandHandler.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/kill/KillCommandHandler.java
@@ -17,10 +17,14 @@
 
 package org.apache.ignite.internal.sql.engine.exec.kill;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.EnumMap;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.lang.IgniteStringFormatter;
 import org.apache.ignite.internal.network.InternalClusterNode;
 import org.apache.ignite.internal.network.MessagingService;
@@ -40,6 +44,7 @@
 /**
  * Handler of SQL KILL command.
  */
+@Singleton
 public class KillCommandHandler implements KillHandlerRegistry {
     private static final SqlQueryMessagesFactory FACTORY = new SqlQueryMessagesFactory();
 
@@ -53,6 +58,16 @@ public class KillCommandHandler implements KillHandlerRegistry {
 
     private final MessagingService messageService;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public KillCommandHandler(
+            NodeIdentity nodeIdentity,
+            LogicalTopologyService logicalTopologyService,
+            @Named("clusterMessaging") MessagingService messageService
+    ) {
+        this(nodeIdentity.nodeName(), logicalTopologyService, messageService);
+    }
+
     /**
      * Constructor.
      */
diff --git a/modules/system-disaster-recovery/build.gradle b/modules/system-disaster-recovery/build.gradle
index c6198d547e42..5ce494a6211a 100644
--- a/modules/system-disaster-recovery/build.gradle
+++ b/modules/system-disaster-recovery/build.gradle
@@ -22,9 +22,13 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     api project(':ignite-system-disaster-recovery-api')
 
     implementation project(':ignite-core')
+    implementation project(':ignite-di')
+    implementation libs.micronaut.inject
     implementation project(':ignite-network-api')
     implementation project(':ignite-vault')
     implementation project(':ignite-cluster-management')
diff --git a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java
index 731827fc0438..35f21e4dff00 100644
--- a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java
+++ b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java
@@ -19,10 +19,14 @@
 
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.ClusterIdStore;
 import org.apache.ignite.internal.cluster.management.ClusterState;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.message.ResetClusterMessage;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
@@ -35,6 +39,9 @@
  *
  * <p>This MUST be started after the Vault, but before networking.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(800)
 public class ClusterIdService implements ClusterIdSupplier, ClusterIdStore, IgniteComponent {
     private final SystemDisasterRecoveryStorage storage;
 
diff --git a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/MetastorageRepairImpl.java b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/MetastorageRepairImpl.java
index 2c5accaea8b4..bf4ac78b155c 100644
--- a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/MetastorageRepairImpl.java
+++ b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/MetastorageRepairImpl.java
@@ -23,6 +23,9 @@
 import static org.apache.ignite.internal.util.CollectionUtils.difference;
 import static org.apache.ignite.internal.util.CompletableFutures.allOf;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
@@ -50,6 +53,7 @@
 /**
  * Implementation of {@link MetastorageRepair}.
  */
+@Singleton
 public class MetastorageRepairImpl implements MetastorageRepair {
     private static final IgniteLogger LOG = Loggers.forClass(MetastorageRepairImpl.class);
 
@@ -63,8 +67,9 @@ public class MetastorageRepairImpl implements MetastorageRepair {
     private final SystemDisasterRecoveryMessagesFactory messagesFactory = new SystemDisasterRecoveryMessagesFactory();
 
     /** Constructor. */
+    @Inject
     public MetastorageRepairImpl(
-            MessagingService messagingService,
+            @Named("clusterMessaging") MessagingService messagingService,
             LogicalTopology logicalTopology,
             ClusterManagementGroupManager cmgManager
     ) {
diff --git a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryManagerImpl.java b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryManagerImpl.java
index f8cdab0671ea..127d2f229a87 100644
--- a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryManagerImpl.java
+++ b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryManagerImpl.java
@@ -27,6 +27,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.allOf;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -42,6 +46,9 @@
 import org.apache.ignite.internal.cluster.management.ClusterState;
 import org.apache.ignite.internal.cluster.management.network.messages.CmgMessagesFactory;
 import org.apache.ignite.internal.cluster.management.network.messages.SuccessResponseMessage;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.exception.ClusterResetException;
 import org.apache.ignite.internal.disaster.system.exception.MigrateException;
 import org.apache.ignite.internal.disaster.system.message.BecomeMetastorageLeaderMessage;
@@ -69,6 +76,9 @@
 /**
  * Implementation of {@link SystemDisasterRecoveryManager}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(900)
 public class SystemDisasterRecoveryManagerImpl implements SystemDisasterRecoveryManager, IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(SystemDisasterRecoveryManagerImpl.class);
 
@@ -89,6 +99,22 @@ public class SystemDisasterRecoveryManagerImpl implements SystemDisasterRecovery
 
     private final ClusterManagementGroupManager cmgManager;
 
+    /** Constructor for DI. */
+    @Inject
+    public SystemDisasterRecoveryManagerImpl(
+            NodeIdentity nodeIdentity,
+            TopologyService topologyService,
+            @Named("clusterMessaging") MessagingService messagingService,
+            VaultManager vaultManager,
+            ServerRestarter restarter,
+            MetastorageGroupMaintenance metastorageGroupMaintenance,
+            ClusterManagementGroupManager cmgManager,
+            ClusterIdSupplier clusterIdSupplier
+    ) {
+        this(nodeIdentity.nodeName(), topologyService, messagingService, vaultManager,
+                restarter, metastorageGroupMaintenance, cmgManager, clusterIdSupplier);
+    }
+
     /** Constructor. */
     public SystemDisasterRecoveryManagerImpl(
             String thisNodeName,
diff --git a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryStorage.java b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryStorage.java
index 6aa905b4ee4d..dc5223c9ef10 100644
--- a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryStorage.java
+++ b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryStorage.java
@@ -20,6 +20,7 @@
 import static org.apache.ignite.internal.util.ArrayUtils.BYTE_EMPTY_ARRAY;
 import static org.apache.ignite.internal.util.ByteUtils.uuidToBytes;
 
+import jakarta.inject.Singleton;
 import java.util.UUID;
 import org.apache.ignite.internal.cluster.management.ClusterState;
 import org.apache.ignite.internal.cluster.management.ClusterStatePersistentSerializer;
@@ -35,6 +36,7 @@
 /**
  * Storage used by tools for disaster recovery of system groups.
  */
+@Singleton
 public class SystemDisasterRecoveryStorage implements ClusterResetStorage {
     private static final ByteArray INIT_CONFIG_APPLIED_VAULT_KEY = new ByteArray("systemRecovery.initConfigApplied");
     private static final ByteArray CLUSTER_STATE_VAULT_KEY = new ByteArray("systemRecovery.clusterState");
diff --git a/modules/system-view/build.gradle b/modules/system-view/build.gradle
index 239c5b1ba136..9f59ff444cc0 100644
--- a/modules/system-view/build.gradle
+++ b/modules/system-view/build.gradle
@@ -21,10 +21,13 @@ apply from: "$rootDir/buildscripts/java-junit5.gradle"
 apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     implementation project(':ignite-system-view-api')
 
     implementation project(':ignite-api')
     implementation project(':ignite-core')
+    implementation libs.micronaut.inject
     implementation project(':ignite-catalog')
     implementation project(':ignite-schema')
     implementation project(':ignite-network-api')
diff --git a/modules/system-view/src/main/java/org/apache/ignite/internal/systemview/SystemViewManagerImpl.java b/modules/system-view/src/main/java/org/apache/ignite/internal/systemview/SystemViewManagerImpl.java
index a873afaba6ab..fabc5f341503 100644
--- a/modules/system-view/src/main/java/org/apache/ignite/internal/systemview/SystemViewManagerImpl.java
+++ b/modules/system-view/src/main/java/org/apache/ignite/internal/systemview/SystemViewManagerImpl.java
@@ -23,6 +23,8 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.nio.ByteBuffer;
@@ -50,6 +52,9 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.lang.IgniteInternalException;
@@ -70,6 +75,8 @@
 /**
  * SQL system views manager implementation.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
 public class SystemViewManagerImpl implements SystemViewManager, NodeAttributesProvider, LogicalTopologyEventListener {
     public static final String NODE_ATTRIBUTES_KEY = "sql-system-views";
 
@@ -102,6 +109,12 @@ public class SystemViewManagerImpl implements SystemViewManager, NodeAttributesP
 
     private volatile Map<String, List<String>> owningNodesByViewName = Map.of();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public SystemViewManagerImpl(NodeIdentity nodeIdentity, CatalogManager catalogManager, FailureProcessor failureProcessor) {
+        this(nodeIdentity.nodeName(), catalogManager, failureProcessor);
+    }
+
     /** Creates a system view manager. */
     public SystemViewManagerImpl(String localNodeName, CatalogManager catalogManager, FailureProcessor failureProcessor) {
         this.localNodeName = localNodeName;
diff --git a/modules/table/build.gradle b/modules/table/build.gradle
index 3e54807d2b43..2233d3c006e5 100644
--- a/modules/table/build.gradle
+++ b/modules/table/build.gradle
@@ -25,6 +25,7 @@ dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-api')
     implementation project(':ignite-schema')
@@ -54,6 +55,8 @@ dependencies {
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
+    implementation project(':ignite-di')
 
     testAnnotationProcessor libs.jmh.annotation.processor
     testImplementation project(':ignite-configuration')
@@ -124,6 +127,8 @@ dependencies {
     testFixturesImplementation testFixtures(project(':ignite-marshaller-common'))
     testFixturesImplementation testFixtures(project(':ignite-schema'))
     testFixturesImplementation libs.fastutil.core
+    testFixturesImplementation project(':ignite-di')
+    testFixturesImplementation libs.micronaut.inject
 
 
     integrationTestImplementation project(':ignite-raft-api')
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/PartitionModificationCounterFactory.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/PartitionModificationCounterFactory.java
index 5b15bb98791a..14c1d8898ea3 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/PartitionModificationCounterFactory.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/PartitionModificationCounterFactory.java
@@ -17,11 +17,15 @@
 
 package org.apache.ignite.internal.table.distributed;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Supplier;
+import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.network.InternalClusterNode;
 import org.apache.ignite.internal.network.MessagingService;
@@ -36,12 +40,24 @@
 /**
  * Factory for producing {@link PartitionModificationCounter}.
  */
+@Singleton
 public class PartitionModificationCounterFactory {
     private final Supplier<HybridTimestamp> currentTimestampSupplier;
     private final MessagingService messagingService;
     private final Map<TablePartitionId, PartitionModificationCounter> partitionsInfo = new HashMap<>();
     private static final TableMessagesFactory TABLE_MESSAGES_FACTORY = new TableMessagesFactory();
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public PartitionModificationCounterFactory(
+            ClockService clockService,
+            @Named("clusterMessaging") MessagingService messagingService
+    ) {
+        this(clockService::current, messagingService);
+    }
+
     public PartitionModificationCounterFactory(Supplier<HybridTimestamp> currentTimestampSupplier, MessagingService messagingService) {
         this.currentTimestampSupplier = currentTimestampSupplier;
         this.messagingService = messagingService;
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/TableManager.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/TableManager.java
index 38adc3c38569..f8a99e5cc52a 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/TableManager.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/TableManager.java
@@ -51,7 +51,12 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -87,6 +92,9 @@
 import org.apache.ignite.internal.causality.IncrementalVersionedValue;
 import org.apache.ignite.internal.causality.OutdatedTokenException;
 import org.apache.ignite.internal.causality.RevisionListenerRegistry;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
 import org.apache.ignite.internal.distributionzones.DistributionZonesUtil;
@@ -189,6 +197,9 @@
 /**
  * Table manager.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2400)
 public class TableManager implements IgniteTablesInternal, IgniteComponent {
     /** The logger. */
     private static final IgniteLogger LOG = Loggers.forClass(TableManager.class);
@@ -353,6 +364,51 @@ public class TableManager implements IgniteTablesInternal, IgniteComponent {
     private final Map<TablePartitionId, PartitionTableStatsMetricSource> partModCounterMetricSources = new ConcurrentHashMap<>();
     private final Map<TablePartitionId, LongSupplier> pendingWriteIntentsSuppliers = new ConcurrentHashMap<>();
 
+    /** Constructor for DI. */
+    @Inject
+    public TableManager(
+            NodeIdentity nodeIdentity,
+            RevisionListenerRegistry registry,
+            GcConfiguration gcConfig,
+            ReplicationConfiguration replicationConfiguration,
+            @Named("storageOperations") MessagingService messagingService,
+            TopologyService topologyService,
+            LockManager lockMgr,
+            ReplicaService replicaSvc,
+            TxManager txManager,
+            DataStorageManager dataStorageMgr,
+            MetaStorageManager metaStorageMgr,
+            SchemaManager schemaManager,
+            ValidationSchemasSource validationSchemasSource,
+            @Named("tableIoExecutor") ExecutorService ioExecutor,
+            @Named("partitionOperationsExecutor") Executor partitionOperationsExecutor,
+            ClockService clockService,
+            OutgoingSnapshotsManager outgoingSnapshotsManager,
+            SchemaSyncService schemaSyncService,
+            CatalogService catalogService,
+            FailureProcessor failureProcessor,
+            HybridTimestampTracker observableTimestampTracker,
+            PlacementDriver placementDriver,
+            Provider<IgniteSql> sqlProvider,
+            RemotelyTriggeredResourceRegistry remotelyTriggeredResourceRegistry,
+            LowWatermark lowWatermark,
+            TransactionInflights transactionInflights,
+            IndexMetaStorage indexMetaStorage,
+            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            MinimumRequiredTimeCollectorService minTimeCollectorService,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            MetricManager metricManager,
+            PartitionModificationCounterFactory partitionModificationCounterFactory
+    ) {
+        this(nodeIdentity.nodeName(), registry, gcConfig, replicationConfiguration, messagingService, topologyService,
+                lockMgr, replicaSvc, txManager, dataStorageMgr, metaStorageMgr, schemaManager, validationSchemasSource,
+                ioExecutor, partitionOperationsExecutor, clockService, outgoingSnapshotsManager, schemaSyncService,
+                catalogService, failureProcessor, observableTimestampTracker, placementDriver, sqlProvider::get,
+                remotelyTriggeredResourceRegistry, lowWatermark, transactionInflights, indexMetaStorage,
+                partitionReplicaLifecycleManager, minTimeCollectorService, systemDistributedConfiguration,
+                metricManager, partitionModificationCounterFactory);
+    }
+
     /**
      * Creates a new table manager.
      *
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/disaster/DisasterRecoveryManager.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/disaster/DisasterRecoveryManager.java
index 1ef6aac79f03..5a0182422df7 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/disaster/DisasterRecoveryManager.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/disaster/DisasterRecoveryManager.java
@@ -47,6 +47,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.lang.ErrorGroups.DisasterRecovery.PARTITION_STATE_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -59,6 +63,7 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.apache.ignite.internal.catalog.Catalog;
@@ -72,6 +77,8 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.distributionzones.DistributionZonesUtil;
 import org.apache.ignite.internal.distributionzones.NodeWithAttributes;
@@ -144,6 +151,9 @@
  * such as {@link #resetPartitions(String, Set)}.
  * More details are in the <a href="https://issues.apache.org/jira/browse/IGNITE-21140">epic</a>.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2500)
 public class DisasterRecoveryManager implements IgniteComponent, SystemViewProvider {
     /** Logger. */
     static final IgniteLogger LOG = Loggers.forClass(DisasterRecoveryManager.class);
@@ -223,6 +233,40 @@ public class DisasterRecoveryManager implements IgniteComponent, SystemViewProvi
 
     private final Map<UUID, MultiNodeOperations> operationsByNodeId = new ConcurrentHashMap<>();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public DisasterRecoveryManager(
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
+            @Named("storageOperations") MessagingService messagingService,
+            MetaStorageManager metaStorageManager,
+            CatalogManager catalogManager,
+            DistributionZoneManager distributionZoneManager,
+            Loza raftManager,
+            TopologyService topologyService,
+            LogicalTopologyService logicalTopologyService,
+            TableManager tableManager,
+            MetricManager metricManager,
+            FailureManager failureManager,
+            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            SystemViewManager systemViewManager
+    ) {
+        this(
+                (ExecutorService) tableIoExecutor,
+                messagingService,
+                metaStorageManager,
+                catalogManager,
+                distributionZoneManager,
+                raftManager,
+                topologyService,
+                logicalTopologyService,
+                tableManager,
+                metricManager,
+                failureManager,
+                partitionReplicaLifecycleManager,
+                systemViewManager
+        );
+    }
+
     /** Constructor. */
     public DisasterRecoveryManager(
             ExecutorService threadPool,
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java
index 9a6afb2df4c4..9a8d6bc85bd8 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java
@@ -45,6 +45,8 @@
 import static org.apache.ignite.internal.util.CompletableFutures.falseCompletedFuture;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
@@ -69,6 +71,8 @@
 import org.apache.ignite.internal.catalog.events.StartBuildingIndexEventParameters;
 import org.apache.ignite.internal.catalog.events.StoppingIndexEventParameters;
 import org.apache.ignite.internal.catalog.events.TableEventParameters;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.event.EventListener;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lang.ByteArray;
@@ -111,6 +115,9 @@
  *     less than or equal to the active catalog version for the new watermark.</li>
  * </ul>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(400)
 public class IndexMetaStorage implements IgniteComponent {
     private static final String INDEX_META_VERSION_KEY_PREFIX = "index.meta.version.";
 
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/raft/MinimumRequiredTimeCollectorServiceImpl.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/raft/MinimumRequiredTimeCollectorServiceImpl.java
index c20c8bb7360b..f5e45e388f5e 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/raft/MinimumRequiredTimeCollectorServiceImpl.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/raft/MinimumRequiredTimeCollectorServiceImpl.java
@@ -17,12 +17,14 @@
 
 package org.apache.ignite.internal.table.distributed.raft;
 
+import jakarta.inject.Singleton;
 import java.util.Collections;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import org.apache.ignite.internal.replicator.TablePartitionId;
 
 /** Collects minimum required timestamp for each partition. */
+@Singleton
 public class MinimumRequiredTimeCollectorServiceImpl implements MinimumRequiredTimeCollectorService {
     private final ConcurrentHashMap<TablePartitionId, Long> partitions = new ConcurrentHashMap<>();
 
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/schema/SchemaSyncServiceImpl.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/schema/SchemaSyncServiceImpl.java
index 0a1b3e6a7520..7873c6cc23cc 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/schema/SchemaSyncServiceImpl.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/schema/SchemaSyncServiceImpl.java
@@ -17,8 +17,11 @@
 
 package org.apache.ignite.internal.table.distributed.schema;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.LongSupplier;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.schema.SchemaSafeTimeTracker;
 import org.apache.ignite.internal.schema.SchemaSyncService;
@@ -26,11 +29,23 @@
 /**
  * A default implementation of {@link SchemaSyncService}.
  */
+@Singleton
 public class SchemaSyncServiceImpl implements SchemaSyncService {
     private final SchemaSafeTimeTracker schemaSafeTimeTracker;
 
     private final LongSupplier delayDurationMs;
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public SchemaSyncServiceImpl(
+            SchemaSafeTimeTracker schemaSafeTimeTracker,
+            SchemaSynchronizationConfiguration schemaSyncConfig
+    ) {
+        this(schemaSafeTimeTracker, () -> schemaSyncConfig.delayDurationMillis().value());
+    }
+
     /**
      * Constructor.
      */
diff --git a/modules/transactions/build.gradle b/modules/transactions/build.gradle
index fae253133f63..dd7f412c9967 100644
--- a/modules/transactions/build.gradle
+++ b/modules/transactions/build.gradle
@@ -26,6 +26,7 @@ dependencies {
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     api project(':ignite-configuration-system')
     api project(':ignite-storage-api')
@@ -49,6 +50,7 @@ dependencies {
     implementation libs.auto.service.annotations
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
+    implementation libs.micronaut.inject
 
     testImplementation project(':ignite-core')
     testImplementation testFixtures(project(':ignite-core'))
@@ -108,6 +110,7 @@ dependencies {
     testFixturesImplementation project(':ignite-distribution-zones')
     testFixturesImplementation project(':ignite-table')
     testFixturesImplementation testFixtures(project(':ignite-core'))
+    testFixturesImplementation libs.micronaut.inject
 }
 
 description = 'ignite-transactions'
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
index b9ae7002c0f9..c2403f6afa42 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
@@ -23,6 +23,8 @@
 import static org.apache.ignite.internal.tx.event.LockEvent.LOCK_CONFLICT;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Comparator;
@@ -77,6 +79,7 @@
  *
  * <p>Additionally limits the lock map size.
  */
+@Singleton
 public class HeapLockManager extends AbstractEventProducer<LockEvent, LockEventParameters> implements LockManager {
     /** Table size. */
     public static final int DEFAULT_SLOTS = 1_048_576;
@@ -124,6 +127,7 @@ public static HeapLockManager smallInstance() {
     }
 
     /** Constructor. */
+    @Inject
     public HeapLockManager(SystemLocalConfiguration systemProperties, VolatileTxStateMetaStorage txStateVolatileStorage) {
         this(intProperty(systemProperties, LOCK_MAP_SIZE_PROPERTY_NAME, DEFAULT_SLOTS), txStateVolatileStorage);
     }
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/RemotelyTriggeredResourceRegistry.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/RemotelyTriggeredResourceRegistry.java
index 823434b37410..8e8df2134901 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/RemotelyTriggeredResourceRegistry.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/RemotelyTriggeredResourceRegistry.java
@@ -20,6 +20,7 @@
 import static java.util.Collections.unmodifiableMap;
 import static java.util.Collections.unmodifiableSet;
 
+import jakarta.inject.Singleton;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -37,6 +38,7 @@
 /**
  * This registry keeps track of the resources that were created by remote nodes.
  */
+@Singleton
 public class RemotelyTriggeredResourceRegistry {
     /** The logger. */
     private static final IgniteLogger LOG = Loggers.forClass(RemotelyTriggeredResourceRegistry.class);
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/ResourceVacuumManager.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/ResourceVacuumManager.java
index bcbaaf9fc0b7..1c50fe126a8e 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/ResourceVacuumManager.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/ResourceVacuumManager.java
@@ -21,6 +21,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.internal.util.IgniteUtils.shutdownAndAwaitTermination;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -28,6 +32,9 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.lang.IgniteSystemProperties;
@@ -48,6 +55,9 @@
 /**
  * Manager responsible from cleaning up the transaction resources.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(3300)
 public class ResourceVacuumManager implements IgniteComponent {
     /** The logger. */
     private static final IgniteLogger LOG = Loggers.forClass(ResourceVacuumManager.class);
@@ -86,6 +96,44 @@ public class ResourceVacuumManager implements IgniteComponent {
     private volatile ScheduledFuture<?> vacuumOperationFuture;
     private volatile ScheduledFuture<?> broadcastClosedTransactionsFuture;
 
+    /**
+     * Constructor for dependency injection.
+     *
+     * @param nodeIdentity Node identity.
+     * @param resourceRegistry Resources registry.
+     * @param topologyService Topology service.
+     * @param messagingService Messaging service.
+     * @param transactionInflights Transaction inflights.
+     * @param txManager Transactional manager.
+     * @param lowWatermark Low watermark.
+     * @param failureProcessor Failure processor.
+     * @param metricManager Metric manager.
+     */
+    @Inject
+    public ResourceVacuumManager(
+            NodeIdentity nodeIdentity,
+            RemotelyTriggeredResourceRegistry resourceRegistry,
+            TopologyService topologyService,
+            @Named("storageOperations") MessagingService messagingService,
+            TransactionInflights transactionInflights,
+            TxManager txManager,
+            LowWatermark lowWatermark,
+            FailureProcessor failureProcessor,
+            MetricManager metricManager
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                resourceRegistry,
+                topologyService,
+                messagingService,
+                transactionInflights,
+                txManager,
+                lowWatermark,
+                failureProcessor,
+                metricManager
+        );
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionIdGenerator.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionIdGenerator.java
index e40aef864523..69a3ca6e0f1e 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionIdGenerator.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionIdGenerator.java
@@ -17,18 +17,30 @@
 
 package org.apache.ignite.internal.tx.impl;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.UUID;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
+import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.tx.TransactionIds;
 import org.apache.ignite.internal.tx.TxPriority;
 
 /**
  * Generates transaction IDs.
  */
+@Singleton
 public class TransactionIdGenerator {
     /** Supplies nodeId for transactionId generation. */
     private final NodeIdSupplier nodeIdSupplier;
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public TransactionIdGenerator(ClusterService clusterService) {
+        this(() -> clusterService.nodeName().hashCode());
+    }
+
     public TransactionIdGenerator(NodeIdSupplier nodeIdSupplier) {
         this.nodeIdSupplier = nodeIdSupplier;
     }
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionInflights.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionInflights.java
index 83934e5773a2..1ef0e11833da 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionInflights.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionInflights.java
@@ -27,6 +27,8 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.unwrapCause;
 import static org.apache.ignite.lang.ErrorGroups.Transactions.TX_PRIMARY_REPLICA_EXPIRED_ERR;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -50,6 +52,7 @@
  * Read-only transactions can't be included into {@link org.apache.ignite.internal.tx.message.FinishedTransactionsBatchMessage} when
  * some requests are in-flight.
  */
+@Singleton
 public class TransactionInflights {
     /** Hint for maximum concurrent txns. */
     private static final int MAX_CONCURRENT_TXNS = 1024;
@@ -70,6 +73,7 @@ public class TransactionInflights {
      * @param clockService Clock service.
      * @param txStateVolatileStorage Volatile transaction meta storage.
      */
+    @Inject
     public TransactionInflights(
             PlacementDriver placementDriver,
             ClockService clockService,
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
index 0bd927e95ccb..7bc27d2920ad 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
@@ -41,6 +41,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.internal.util.IgniteUtils.shutdownAndAwaitTermination;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -60,6 +64,9 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.SystemPropertyView;
 import org.apache.ignite.internal.event.EventListener;
@@ -87,6 +94,7 @@
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.replicator.ReplicatorRecoverableExceptions;
 import org.apache.ignite.internal.replicator.ZonePartitionId;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.replicator.message.ErrorReplicaResponse;
 import org.apache.ignite.internal.replicator.message.ReplicaMessageGroup;
 import org.apache.ignite.internal.replicator.message.ReplicaResponse;
@@ -128,6 +136,9 @@
  *
  * <p>Uses 2PC for atomic commitment and 2PL for concurrency control.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1700)
 public class TxManagerImpl implements TxManager, NetworkMessageHandler, SystemViewProvider {
     private static final String ABANDONED_CHECK_TS_PROP = "txnAbandonedCheckTs";
 
@@ -239,6 +250,56 @@ public class TxManagerImpl implements TxManager, NetworkMessageHandler, SystemVi
 
     private final ConcurrentLinkedQueue<CompletableFuture<?>> stopFuts = new ConcurrentLinkedQueue<>();
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public TxManagerImpl(
+            NodeIdentity nodeIdentity,
+            TransactionConfiguration txConfig,
+            SystemDistributedConfiguration systemCfg,
+            @Named("storageOperations") MessagingService messagingService,
+            TopologyService topologyService,
+            ReplicaService replicaService,
+            LockManager lockManager,
+            VolatileTxStateMetaStorage txStateVolatileStorage,
+            ClockService clockService,
+            TransactionIdGenerator transactionIdGenerator,
+            PlacementDriver placementDriver,
+            ReplicationConfiguration replicationConfiguration,
+            LocalRwTxCounter localRwTxCounter,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
+            RemotelyTriggeredResourceRegistry resourcesRegistry,
+            TransactionInflights transactionInflights,
+            LowWatermark lowWatermark,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
+            FailureProcessor failureProcessor,
+            MetricManager metricManager
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                txConfig,
+                systemCfg,
+                messagingService,
+                topologyService,
+                replicaService,
+                lockManager,
+                txStateVolatileStorage,
+                clockService,
+                transactionIdGenerator,
+                placementDriver,
+                () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
+                localRwTxCounter,
+                partitionOperationsExecutor,
+                resourcesRegistry,
+                transactionInflights,
+                lowWatermark,
+                commonScheduler,
+                failureProcessor,
+                metricManager
+        );
+    }
+
     /**
      * Test-only constructor.
      *
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/VolatileTxStateMetaStorage.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/VolatileTxStateMetaStorage.java
index 19396b007ad2..f78904e3bc60 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/VolatileTxStateMetaStorage.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/VolatileTxStateMetaStorage.java
@@ -20,6 +20,7 @@
 import static org.apache.ignite.internal.tx.TxState.PENDING;
 import static org.apache.ignite.internal.tx.TxState.checkTransitionCorrectness;
 
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -45,6 +46,7 @@
 /**
  * The class represents volatile transaction state storage that stores a transaction state meta until the node stops.
  */
+@Singleton
 public class VolatileTxStateMetaStorage {
     /** The local map for tx states. */
     private ConcurrentHashMap<UUID, TxStateMeta> txStateMap;
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/storage/state/rocksdb/TxStateRocksDbSharedStorage.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/storage/state/rocksdb/TxStateRocksDbSharedStorage.java
index 378a0335fef7..2497e2e52977 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/storage/state/rocksdb/TxStateRocksDbSharedStorage.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/storage/state/rocksdb/TxStateRocksDbSharedStorage.java
@@ -27,6 +27,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.closeAll;
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.file.Files;
@@ -42,7 +46,11 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.IntSupplier;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.LogSyncer;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
@@ -68,6 +76,9 @@
  * as well as reducing the amount of resources that would otherwise be used by multiple RocksDB instances, if they existed
  * on per-zone basis.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1800)
 public class TxStateRocksDbSharedStorage implements IgniteComponent {
     static {
         RocksDB.loadLibrary();
@@ -127,6 +138,22 @@ public class TxStateRocksDbSharedStorage implements IgniteComponent {
 
     private volatile ColumnFamily txStateMetaColumnFamily;
 
+    /**
+     * DI constructor.
+     */
+    @Inject
+    public TxStateRocksDbSharedStorage(
+            NodeIdentity nodeIdentity,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir,
+            @Named("commonScheduler") ScheduledExecutorService scheduledExecutor,
+            @Named("tableIoExecutor") ScheduledExecutorService threadPool,
+            @Named("partitions") LogSyncer logSyncer,
+            FailureProcessor failureProcessor
+    ) {
+        this(nodeIdentity.nodeName(), partitionsWorkDir.dbPath().resolve("tx-state"),
+                scheduledExecutor, threadPool, logSyncer, failureProcessor);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/vault/build.gradle b/modules/vault/build.gradle
index b9d81a5fff4f..0498c7b5f51d 100644
--- a/modules/vault/build.gradle
+++ b/modules/vault/build.gradle
@@ -21,7 +21,11 @@ apply from: "$rootDir/buildscripts/java-junit5.gradle"
 apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     implementation project(':ignite-core')
+    implementation project(':ignite-di')
+    implementation libs.micronaut.inject
     implementation project(':ignite-rocksdb-common')
     implementation libs.jetbrains.annotations
     implementation libs.rocksdb.jni
@@ -30,6 +34,8 @@ dependencies {
     testImplementation testFixtures(project(':ignite-core'))
 
     testFixturesImplementation project(':ignite-core')
+    testFixturesImplementation project(':ignite-di')
+    testFixturesImplementation libs.micronaut.inject
 }
 
 description = 'ignite-vault'
diff --git a/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java b/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java
index c390c4068e61..2eb144d16715 100644
--- a/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java
+++ b/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java
@@ -21,8 +21,12 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.internal.util.StringUtils.incrementLastChar;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.ByteArray;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
@@ -32,6 +36,9 @@
 /**
  * VaultManager is responsible for handling {@link VaultService} lifecycle and providing interface for managing local keys.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(200)
 public class VaultManager implements IgniteComponent {
     /** Special key, which reserved for storing the name of the current node. */
     public static final ByteArray NODE_NAME = new ByteArray("node_name");
diff --git a/modules/workers/build.gradle b/modules/workers/build.gradle
index 2bbd7c585cc5..69a31e3404a2 100644
--- a/modules/workers/build.gradle
+++ b/modules/workers/build.gradle
@@ -23,10 +23,12 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.auto.service
 
     implementation project(':ignite-api')
     implementation project(':ignite-core')
+    implementation libs.micronaut.inject
     implementation project(':ignite-configuration-api')
     implementation project(':ignite-configuration-root')
     implementation project(':ignite-failure-handler')
diff --git a/modules/workers/src/main/java/org/apache/ignite/internal/worker/CriticalWorkerWatchdog.java b/modules/workers/src/main/java/org/apache/ignite/internal/worker/CriticalWorkerWatchdog.java
index 4ed463abcdf5..ed691e15ef34 100644
--- a/modules/workers/src/main/java/org/apache/ignite/internal/worker/CriticalWorkerWatchdog.java
+++ b/modules/workers/src/main/java/org/apache/ignite/internal/worker/CriticalWorkerWatchdog.java
@@ -21,8 +21,12 @@
 import static org.apache.ignite.internal.failure.FailureType.SYSTEM_WORKER_BLOCKED;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.longs.Long2LongMap;
 import it.unimi.dsi.fastutil.longs.Long2LongOpenHashMap;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.lang.management.LockInfo;
 import java.lang.management.ManagementFactory;
 import java.lang.management.MonitorInfo;
@@ -34,6 +38,8 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -54,6 +60,9 @@
  * <p>The watchdog periodically performs a check; if it finds a worker that lags more than allowed and it is not in the
  * NOT_MONITORED state, then a logging is triggered.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1000)
 public class CriticalWorkerWatchdog implements CriticalWorkerRegistry, IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(CriticalWorkerWatchdog.class);
 
@@ -77,9 +86,10 @@ public class CriticalWorkerWatchdog implements CriticalWorkerRegistry, IgniteCom
      * @param scheduler Scheduler.
      * @param failureManager Failure processor.
      */
+    @Inject
     public CriticalWorkerWatchdog(
             CriticalWorkersConfiguration configuration,
-            ScheduledExecutorService scheduler,
+            @Named("commonScheduler") ScheduledExecutorService scheduler,
             FailureManager failureManager
     ) {
         this.configuration = configuration;
diff --git a/settings.gradle b/settings.gradle
index e8212ab9d87d..d534d6f59ee9 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -108,6 +108,7 @@ include(':ignite-system-disaster-recovery')
 include(':ignite-system-disaster-recovery-api')
 include(':ignite-compatibility-tests')
 include(':ignite-configuration-storage')
+include(':ignite-di')
 include(':ignite-checkstyle-custom')
 
 project(":ignite-examples").projectDir = file('examples/java')
@@ -194,6 +195,7 @@ project(":ignite-system-disaster-recovery").projectDir = file('modules/system-di
 project(":ignite-system-disaster-recovery-api").projectDir = file('modules/system-disaster-recovery-api')
 project(':ignite-compatibility-tests').projectDir = file('modules/compatibility-tests')
 project(':ignite-configuration-storage').projectDir = file('modules/configuration-storage')
+project(':ignite-di').projectDir = file('modules/di')
 project(':ignite-checkstyle-custom').projectDir = file('modules/checkstyle-custom')
 
 include(":migration-tools-ignite2-repack")