diff --git a/flowfile_core/flowfile_core/flowfile/flow_graph.py b/flowfile_core/flowfile_core/flowfile/flow_graph.py
index 641b28cad..823504920 100644
--- a/flowfile_core/flowfile_core/flowfile/flow_graph.py
+++ b/flowfile_core/flowfile_core/flowfile/flow_graph.py
@@ -840,10 +840,24 @@ def add_user_defined_node(
     ):
         """Adds a user-defined custom node to the graph.
 
+        Routes to kernel execution when the node declares ``use_kernel=True``
+        and a ``kernel_id`` is provided at runtime; otherwise falls back to the
+        standard lazy-plan execution path.
+
         Args:
             custom_node: The custom node instance to add.
             user_defined_node_settings: The settings for the user-defined node.
         """
+        kernel_id = user_defined_node_settings.kernel_id
+        if custom_node.use_kernel and kernel_id:
+            self._add_user_defined_node_kernel(custom_node, user_defined_node_settings, kernel_id)
+        else:
+            self._add_user_defined_node_lazy(custom_node, user_defined_node_settings)
+
+    def _add_user_defined_node_lazy(
+        self, custom_node: CustomNodeBase, user_defined_node_settings: input_schema.UserDefinedNode
+    ):
+        """Standard lazy-plan execution for custom nodes."""
 
         def _func(*flow_data_engine: FlowDataEngine) -> FlowDataEngine | None:
             user_id = user_defined_node_settings.user_id
@@ -872,6 +886,153 @@ def _func(*flow_data_engine: FlowDataEngine) -> FlowDataEngine | None:
             node = self.get_node(user_defined_node_settings.node_id)
             self.add_node_to_starting_list(node)
 
+    # ------------------------------------------------------------------
+    # Kernel-based execution for custom nodes
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _build_kernel_code_for_custom_node(
+        custom_node: CustomNodeBase,
+        settings: Any | None,
+    ) -> str:
+        """Build the Python source sent to the kernel.
+
+        Injects ``import`` statements, a ``self`` namespace that mirrors
+        the node's settings schema (so ``self.settings_schema.section.field.value``
+        works identically to lazy mode), flattened convenience variables,
+        and finally the user's ``kernel_code``.
+        """
+        lines: list[str] = ["import polars as pl", "import flowfile", ""]
+
+        # Inject settings as plain Python variables + a self namespace
+        if settings and isinstance(settings, dict):
+            lines.append("# Settings (injected from node configuration)")
+            lines.append("from types import SimpleNamespace as _NS")
+            lines.append("class _V:")
+            lines.append("    def __init__(self, v): self.value = v; self.secret_value = v")
+
+            section_parts: list[str] = []
+            for section_name, section_values in settings.items():
+                if isinstance(section_values, dict):
+                    field_parts: list[str] = []
+                    for key, value in section_values.items():
+                        lines.append(f"{key} = {repr(value)}")
+                        field_parts.append(f"{key}=_V({repr(value)})")
+                    section_parts.append(f"{section_name}=_NS({', '.join(field_parts)})")
+
+            lines.append(f"self = _NS(settings_schema=_NS({', '.join(section_parts)}))")
+            lines.append("")
+
+        lines.append("# User code")
+        lines.append(custom_node.kernel_code)
+        return "\n".join(lines)
+
+    def _add_user_defined_node_kernel(
+        self,
+        custom_node: CustomNodeBase,
+        user_defined_node_settings: input_schema.UserDefinedNode,
+        kernel_id: str,
+    ):
+        """Execute a custom node inside a kernel container.
+
+        Follows the same pattern as ``add_python_script``: materialise inputs
+        to Parquet via the worker, send the code to the kernel for execution,
+        then read the output Parquet back.
+        """
+
+        def _func(*flowfile_tables: FlowDataEngine) -> FlowDataEngine:
+            manager = get_kernel_manager()
+            node_id = user_defined_node_settings.node_id
+            flow_id = self.flow_id
+            node_logger = self.flow_logger.get_node_logger(node_id)
+
+            shared_base = manager.shared_volume_path
+            input_dir = os.path.join(shared_base, str(flow_id), str(node_id), "inputs")
+            output_dir = os.path.join(shared_base, str(flow_id), str(node_id), "outputs")
+            os.makedirs(input_dir, exist_ok=True)
+            os.makedirs(output_dir, exist_ok=True)
+            self.flow_logger.info(f"Prepared shared directories for kernel execution: {input_dir}, {output_dir}")
+
+            # Materialise inputs to Parquet
+            input_paths: dict[str, list[str]] = {}
+            main_paths: list[str] = []
+            for idx, ft in enumerate(flowfile_tables):
+                filename = f"main_{idx}.parquet"
+                local_path = os.path.join(input_dir, filename)
+                fetcher = ExternalDfFetcher(
+                    flow_id=flow_id,
+                    node_id=node_id,
+                    lf=ft.data_frame,
+                    wait_on_completion=True,
+                    operation_type="write_parquet",
+                    kwargs={"output_path": local_path},
+                )
+                if fetcher.has_error:
+                    raise RuntimeError(f"Failed to write parquet for input {idx}: {fetcher.error_description}")
+                main_paths.append(manager.to_kernel_path(local_path))
+            input_paths["main"] = main_paths
+
+            # Build kernel code with injected settings
+            code = self._build_kernel_code_for_custom_node(custom_node, user_defined_node_settings.settings)
+
+            # Log callback URL
+            if manager._kernel_volume:
+                log_callback_url = f"http://flowfile-core:{SERVER_PORT}/raw_logs"
+            else:
+                log_callback_url = f"http://host.docker.internal:{SERVER_PORT}/raw_logs"
+
+            # Internal auth token
+            internal_token: str | None = None
+            try:
+                from flowfile_core.auth.jwt import get_internal_token
+
+                internal_token = get_internal_token()
+            except (ValueError, ImportError):
+                pass
+
+            reg_id = self._flow_settings.source_registration_id
+            request = ExecuteRequest(
+                node_id=node_id,
+                code=code,
+                input_paths=input_paths,
+                output_dir=manager.to_kernel_path(output_dir),
+                flow_id=flow_id,
+                source_registration_id=reg_id,
+                log_callback_url=log_callback_url,
+                internal_token=internal_token,
+            )
+            result = manager.execute_sync(kernel_id, request, self.flow_logger)
+
+            # Forward stdout / stderr
+            if result.stdout:
+                for line in result.stdout.strip().splitlines():
+                    node_logger.info(f"[stdout] {line}")
+            if result.stderr:
+                for line in result.stderr.strip().splitlines():
+                    node_logger.warning(f"[stderr] {line}")
+
+            if not result.success:
+                raise RuntimeError(f"Kernel execution failed: {result.error}")
+
+            # Read output
+            output_path = os.path.join(output_dir, "main.parquet")
+            if os.path.exists(output_path):
+                return FlowDataEngine(pl.scan_parquet(output_path))
+
+            # No output published – pass through first input
+            return flowfile_tables[0] if flowfile_tables else FlowDataEngine(pl.LazyFrame())
+
+        self.add_node_step(
+            node_id=user_defined_node_settings.node_id,
+            function=_func,
+            setting_input=user_defined_node_settings,
+            input_node_ids=user_defined_node_settings.depending_on_ids,
+            node_type=custom_node.item,
+        )
+        if custom_node.number_of_inputs == 0:
+            node = self.get_node(user_defined_node_settings.node_id)
+            self.add_node_to_starting_list(node)
+
     @with_history_capture(HistoryActionType.UPDATE_SETTINGS)
     def add_pivot(self, pivot_settings: input_schema.NodePivot):
         """Adds a pivot node to the graph.
diff --git a/flowfile_core/flowfile_core/flowfile/node_designer/custom_node.py b/flowfile_core/flowfile_core/flowfile/node_designer/custom_node.py
index e8e0ff565..2362a318b 100644
--- a/flowfile_core/flowfile_core/flowfile/node_designer/custom_node.py
+++ b/flowfile_core/flowfile_core/flowfile/node_designer/custom_node.py
@@ -336,6 +336,11 @@ class CustomNodeBase(BaseModel):
     number_of_inputs: int = 1
     number_of_outputs: int = 1
 
+    # Kernel execution configuration
+    use_kernel: bool = False
+    required_packages: list[str] = []
+    kernel_code: str = ""
+
     # Display properties in the UI
     node_group: str | None = "custom"
     title: str | None = "Custom Node"
@@ -419,6 +424,9 @@ def get_frontend_schema(self) -> dict:
             "node_group": self.node_group,
             "title": self.title,
             "intro": self.intro,
+            "use_kernel": self.use_kernel,
+            "required_packages": self.required_packages,
+            "kernel_code": self.kernel_code,
         }
 
         if self.settings_schema:
diff --git a/flowfile_core/flowfile_core/routes/user_defined_components.py b/flowfile_core/flowfile_core/routes/user_defined_components.py
index bc67addaa..6433bab4d 100644
--- a/flowfile_core/flowfile_core/routes/user_defined_components.py
+++ b/flowfile_core/flowfile_core/routes/user_defined_components.py
@@ -300,17 +300,39 @@ def get_custom_node(file_name: str) -> dict[str, Any]:
                                 result["metadata"]["number_of_inputs"] = value
                             elif attr_name == "number_of_outputs":
                                 result["metadata"]["number_of_outputs"] = value
-
-                    # Extract process method
-                    for item in node.body:
-                        if isinstance(item, ast.FunctionDef) and item.name == "process":
-                            # Get the source code of the process method
-                            start_line = item.lineno - 1
-                            end_line = item.end_lineno if hasattr(item, 'end_lineno') else start_line + 20
-                            lines = content.split('\n')
-                            process_lines = lines[start_line:end_line]
-                            result["processCode"] = '\n'.join(process_lines)
-                            break
+                            elif attr_name == "use_kernel" and isinstance(value, bool):
+                                result["metadata"]["use_kernel"] = value
+                            elif attr_name == "kernel_code" and isinstance(value, str):
+                                result["metadata"]["kernel_code"] = value
+
+                        # Parse list values (e.g. required_packages)
+                        if attr_name == "required_packages":
+                            list_node = None
+                            if isinstance(item, ast.AnnAssign) and item.value:
+                                list_node = item.value
+                            elif isinstance(item, ast.Assign):
+                                list_node = item.value
+                            if isinstance(list_node, ast.List):
+                                packages = []
+                                for elt in list_node.elts:
+                                    if isinstance(elt, ast.Constant) and isinstance(elt.value, str):
+                                        packages.append(elt.value)
+                                result["metadata"]["required_packages"] = packages
+
+                    # Extract process code
+                    if result["metadata"].get("use_kernel"):
+                        # Kernel mode: processCode is the kernel_code attribute
+                        result["processCode"] = result["metadata"].get("kernel_code", "")
+                    else:
+                        # Lazy mode: extract the process method source
+                        for item in node.body:
+                            if isinstance(item, ast.FunctionDef) and item.name == "process":
+                                start_line = item.lineno - 1
+                                end_line = item.end_lineno if hasattr(item, 'end_lineno') else start_line + 20
+                                lines = content.split('\n')
+                                process_lines = lines[start_line:end_line]
+                                result["processCode"] = '\n'.join(process_lines)
+                                break
 
                     break
 
diff --git a/flowfile_core/flowfile_core/schemas/input_schema.py b/flowfile_core/flowfile_core/schemas/input_schema.py
index e244bad18..9333b9d49 100644
--- a/flowfile_core/flowfile_core/schemas/input_schema.py
+++ b/flowfile_core/flowfile_core/schemas/input_schema.py
@@ -1168,3 +1168,4 @@ class UserDefinedNode(NodeMultiInput):
     """Settings for a node that contains the user defined node information"""
 
     settings: Any
+    kernel_id: str | None = None
diff --git a/flowfile_frontend/src/renderer/app/components/nodes/node-types/elements/customNode/CustomNode.vue b/flowfile_frontend/src/renderer/app/components/nodes/node-types/elements/customNode/CustomNode.vue
index c5103cdf2..9d2d09f1e 100644
--- a/flowfile_frontend/src/renderer/app/components/nodes/node-types/elements/customNode/CustomNode.vue
+++ b/flowfile_frontend/src/renderer/app/components/nodes/node-types/elements/customNode/CustomNode.vue
@@ -9,6 +9,67 @@
       {{ schema.intro }}
     </div>
     <generic-node-settings v-model="nodeUserDefined">
+      <!-- Kernel Selection (shown when node requires kernel) -->
+      <div v-if="schema.use_kernel" class="kernel-selection-block">
+        <div class="section-title">Kernel</div>
+        <div class="kernel-row">
+          <el-select
+            v-model="selectedKernelId"
+            placeholder="Select a kernel..."
+            class="kernel-select"
+            size="small"
+            :loading="kernelsLoading"
+            @change="handleKernelChange"
+          >
+            <el-option
+              v-for="kernel in kernels"
+              :key="kernel.id"
+              :value="kernel.id"
+              :label="`${kernel.name} (${kernel.state})`"
+              :disabled="!kernelMatchesRequirements(kernel)"
+            >
+              <span class="kernel-option">
+                <span
+                  class="kernel-state-dot"
+                  :class="`kernel-state-dot--${kernel.state}`"
+                ></span>
+                <span>{{ kernel.name }}</span>
+                <span class="kernel-state-label">({{ kernel.state }})</span>
+                <span
+                  v-if="!kernelMatchesRequirements(kernel)"
+                  class="kernel-missing"
+                  :title="`Missing: ${getMissingPackages(kernel).join(', ')}`"
+                >
+                  missing packages
+                </span>
+              </span>
+            </el-option>
+          </el-select>
+          <router-link :to="{ name: 'kernelManager' }" class="manage-kernels-link">
+            Manage Kernels
+          </router-link>
+        </div>
+        <div v-if="schema.required_packages.length > 0" class="required-packages">
+          <span class="packages-label">Required:</span>
+          <span
+            v-for="pkg in schema.required_packages"
+            :key="pkg"
+            class="package-tag"
+          >{{ pkg }}</span>
+        </div>
+        <div v-if="!selectedKernelId" class="kernel-warning">
+          <i class="fa-solid fa-triangle-exclamation"></i>
+          No kernel selected. A kernel is required to run this node.
+        </div>
+        <div v-else-if="selectedKernelState && selectedKernelState !== 'idle'" class="kernel-warning">
+          <i class="fa-solid fa-triangle-exclamation"></i>
+          Kernel is {{ selectedKernelState }}.
+          <template v-if="selectedKernelState === 'stopped'">Start it from the Kernel Manager.</template>
+          <template v-else-if="selectedKernelState === 'error'">Check the Kernel Manager for details.</template>
+          <template v-else-if="selectedKernelState === 'starting'">Please wait for it to become idle.</template>
+        </div>
+      </div>
+
       <!-- Loop through each section in the settings_schema -->
       <div
         v-for="(section, sectionKey) in schema.settings_schema"
@@ -97,12 +158,14 @@
 </template>
 
 <script setup lang="ts">
-import { ref } from "vue";
+import { ref, computed, onUnmounted } from "vue";
 import { CustomNodeSchema, SectionComponent } from "./interface";
 import { getCustomNodeSchema } from "./interface";
 import { useNodeStore } from "../../../../../stores/column-store";
 import { NodeUserDefined } from "../../../baseNode/nodeInput";
 import { NodeData, FileColumn } from "../../../baseNode/nodeInterfaces";
+import type { KernelInfo } from "../../../../../types/kernel.types";
+import { KernelApi } from "../../../../../api/kernel.api";
 import GenericNodeSettings from "../../../baseNode/genericNodeSettings.vue";
 // Import individual UI components
 import MultiSelect from "./components/MultiSelect.vue";
@@ -127,6 +190,70 @@ const currentNodeId = ref<number | null>(null);
 const nodeUserDefined = ref<NodeUserDefined | null>(null);
 const columnTypes = ref<FileColumn[]>([]);
 
+// Kernel state
+const kernels = ref<KernelInfo[]>([]);
+const kernelsLoading = ref(false);
+const selectedKernelId = ref<string | null>(null);
+let kernelPollTimer: ReturnType<typeof setInterval> | null = null;
+
+const selectedKernelState = computed(() => {
+  if (!selectedKernelId.value) return null;
+  const kernel = kernels.value.find((k) => k.id === selectedKernelId.value);
+  return kernel?.state ?? null;
+});
+
+function kernelMatchesRequirements(kernel: KernelInfo): boolean {
+  const required = schema.value?.required_packages ?? [];
+  if (required.length === 0) return true;
+  const installed = new Set(kernel.packages.map((p) => p.toLowerCase()));
+  return required.every((pkg) => installed.has(pkg.toLowerCase()));
+}
+
+function getMissingPackages(kernel: KernelInfo): string[] {
+  const required = schema.value?.required_packages ?? [];
+  const installed = new Set(kernel.packages.map((p) => p.toLowerCase()));
+  return required.filter((pkg) => !installed.has(pkg.toLowerCase()));
+}
+
+const loadKernels = async () => {
+  kernelsLoading.value = true;
+  try {
+    kernels.value = await KernelApi.getAll();
+  } catch (err) {
+    console.error("Failed to load kernels:", err);
+  } finally {
+    kernelsLoading.value = false;
+  }
+};
+
+const startKernelPolling = () => {
+  stopKernelPolling();
+  kernelPollTimer = setInterval(async () => {
+    try {
+      kernels.value = await KernelApi.getAll();
+    } catch {
+      // Silently ignore poll errors
+    }
+  }, 5000);
+};
+
+const stopKernelPolling = () => {
+  if (kernelPollTimer !== null) {
+    clearInterval(kernelPollTimer);
+    kernelPollTimer = null;
+  }
+};
+
+const handleKernelChange = (kernelId: string | null) => {
+  if (nodeUserDefined.value) {
+    nodeUserDefined.value.kernel_id = kernelId ?? null;
+  }
+};
+
+onUnmounted(() => {
+  stopKernelPolling();
+});
+
 // --- Lifecycle Methods (exposed to parent) ---
 
 const loadNodeData = async (nodeId: number) => {
@@ -159,6 +286,13 @@ const loadNodeData = async (nodeId: number) => {
     }
 
     initializeFormData(schemaData, inputNodeData?.setting_input);
+
+    // Load kernels if this is a kernel-backed node
+    if (schemaData.use_kernel) {
+      selectedKernelId.value = nodeUserDefined.value?.kernel_id ?? null;
+      await loadKernels();
+      startKernelPolling();
+    }
   } catch (err: any) {
     error.value = err.message || "An unknown error occurred while loading node data.";
   } finally {
@@ -175,6 +309,9 @@ const pushNodeData = async () => {
     nodeUserDefined.value.settings = formData.value;
     nodeUserDefined.value.is_user_defined = true;
     nodeUserDefined.value.is_setup = true;
+    if (schema.value?.use_kernel) {
+      nodeUserDefined.value.kernel_id = selectedKernelId.value;
+    }
   }
   nodeStore.updateUserDefinedSettings(nodeUserDefined);
 };
@@ -266,4 +403,115 @@ defineExpose({
   border-radius: var(--border-radius-md, 6px);
   border-left: 3px solid var(--color-accent, #0891b2);
 }
+
+/* Kernel selection */
+.kernel-selection-block {
+  margin-bottom: 1rem;
+}
+
+.kernel-row {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.kernel-select {
+  flex: 1;
+}
+
+.manage-kernels-link {
+  font-size: 0.8rem;
+  color: var(--el-color-primary);
+  text-decoration: none;
+  white-space: nowrap;
+}
+
+.manage-kernels-link:hover {
+  text-decoration: underline;
+}
+
+.kernel-option {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.kernel-state-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+
+.kernel-state-dot--idle {
+  background-color: #67c23a;
+}
+
+.kernel-state-dot--executing {
+  background-color: #e6a23c;
+}
+
+.kernel-state-dot--starting {
+  background-color: #409eff;
+}
+
+.kernel-state-dot--stopped {
+  background-color: #909399;
+}
+
+.kernel-state-dot--error {
+  background-color: #f56c6c;
+}
+
+.kernel-state-label {
+  font-size: 0.8rem;
+  color: var(--el-text-color-secondary);
+}
+
+.kernel-missing {
+  font-size: 0.7rem;
+  color: var(--el-color-danger);
+  font-style: italic;
+}
+
+.required-packages {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 0.3rem;
+  margin-top: 0.5rem;
+  font-size: 0.8rem;
+}
+
+.packages-label {
+  font-weight: 500;
+  color: var(--color-text-secondary);
+  margin-right: 0.25rem;
+}
+
+.package-tag {
+  display: inline-flex;
+  padding: 0.1rem 0.4rem;
+  background-color: var(--el-color-primary-light-9, #ecf5ff);
+  color: var(--el-color-primary, #409eff);
+  border-radius: 3px;
+  font-size: 0.75rem;
+}
+
+.kernel-warning {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.35rem 0.6rem;
+  margin-top: 0.5rem;
+  font-size: 0.75rem;
+  color: var(--el-color-warning-dark-2, #b88230);
+  background-color: var(--el-color-warning-light-9, #fdf6ec);
+  border: 1px solid var(--el-color-warning-light-5, #f3d19e);
+  border-radius: 4px;
+}
+
+.kernel-warning i {
+  flex-shrink: 0;
+}
 </style>
diff --git a/flowfile_frontend/src/renderer/app/components/nodes/node-types/elements/customNode/interface.ts b/flowfile_frontend/src/renderer/app/components/nodes/node-types/elements/customNode/interface.ts
index d60d3876d..bd61f0fdd 100644
--- a/flowfile_frontend/src/renderer/app/components/nodes/node-types/elements/customNode/interface.ts
+++ b/flowfile_frontend/src/renderer/app/components/nodes/node-types/elements/customNode/interface.ts
@@ -130,6 +130,9 @@ export interface CustomNodeSchema {
   intro?: string;
   node_type: NodeTypeLiteral;
   transform_type: TransformTypeLiteral;
+  use_kernel: boolean;
+  required_packages: string[];
+  kernel_code: string;
 }
 
 // --- API function to fetch the schema ---
diff --git a/flowfile_frontend/src/renderer/app/pages/NodeDesigner.vue b/flowfile_frontend/src/renderer/app/pages/NodeDesigner.vue
index b9779cfda..3df25321a 100644
--- a/flowfile_frontend/src/renderer/app/pages/NodeDesigner.vue
+++ b/flowfile_frontend/src/renderer/app/pages/NodeDesigner.vue
@@ -111,6 +111,52 @@
                 <IconSelector v-model="nodeMetadata.node_icon" />
               </div>
             </div>
+
+            <!-- Kernel Execution -->
+            <div class="kernel-section">
+              <div class="kernel-toggle">
+                <label class="toggle-label">
+                  <input
+                    type="checkbox"
+                    v-model="nodeMetadata.use_kernel"
+                    @change="handleKernelToggle"
+                  />
+                  <span>Execute in Kernel</span>
+                </label>
+                <span class="kernel-hint">Run in a Docker container with custom packages</span>
+              </div>
+
+              <div v-if="nodeMetadata.use_kernel" class="kernel-config">
+                <div class="form-field">
+                  <label>Required Packages</label>
+                  <div class="package-input-row">
+                    <input
+                      v-model="newPackageName"
+                      type="text"
+                      class="form-input"
+                      placeholder="e.g. scikit-learn"
+                      @keydown.enter.prevent="addPackage"
+                    />
+                    <button class="add-package-btn" title="Add package" @click="addPackage">
+                      <i class="fa-solid fa-plus"></i>
+                    </button>
+                  </div>
+                  <div v-if="nodeMetadata.required_packages.length > 0" class="package-tags">
+                    <span
+                      v-for="(pkg, idx) in nodeMetadata.required_packages"
+                      :key="idx"
+                      class="package-tag"
+                    >
+                      {{ pkg }}
+                      <button class="remove-tag-btn" @click="removePackage(idx)">&times;</button>
+                    </span>
+                  </div>
+                  <span class="field-hint">
+                    At runtime, select a kernel with these packages installed.
+                  </span>
+                </div>
+              </div>
+            </div>
           </div>
 
           <!-- Sections -->
@@ -150,7 +196,11 @@
           </div>
 
           <!-- Python Code Editor -->
-          <ProcessCodeEditor v-model="processCode" :extensions="autocompletion.extensions" />
+          <ProcessCodeEditor
+            v-model="processCode"
+            :extensions="autocompletion.extensions"
+            :use-kernel="nodeMetadata.use_kernel"
+          />
         </div>
       </div>
 
@@ -158,6 +208,7 @@
       <PropertyEditor
         :component="selectedComponent"
         :section-name="selectedSectionName"
+        :use-kernel="nodeMetadata.use_kernel"
         @update="handlePropertyUpdate"
         @insert-variable="handleInsertVariable"
       />
@@ -222,6 +273,7 @@ import {
   toSnakeCase,
 } from "./nodeDesigner/composables";
 import type { DesignerComponent } from "./nodeDesigner/types";
+import { defaultProcessCode, defaultKernelCode } from "./nodeDesigner/constants";
 
 // Initialize composables - destructure for proper TypeScript support
 const {
@@ -253,6 +305,9 @@ const storage = useSessionStorage(getState, setState, resetState);
 // Help modal state
 const showHelpModal = ref(false);
 
+// Package input state
+const newPackageName = ref("");
+
 // Setup auto-save and load on mount
 watch([() => ({ ...nodeMetadata }), sections, processCode], () => storage.saveToSessionStorage(), {
   deep: true,
@@ -267,6 +322,32 @@ function handleNew() {
   storage.clearSessionStorage();
 }
 
+function handleKernelToggle() {
+  const isDefault =
+    processCode.value === defaultProcessCode || processCode.value === defaultKernelCode;
+  if (nodeMetadata.use_kernel) {
+    if (isDefault || confirm("Switch to kernel code template? Current code will be replaced.")) {
+      processCode.value = defaultKernelCode;
+    }
+  } else {
+    if (isDefault || confirm("Switch back to process method template? Current code will be replaced.")) {
+      processCode.value = defaultProcessCode;
+    }
+  }
+}
+
+function addPackage() {
+  const name = newPackageName.value.trim();
+  if (name && !nodeMetadata.required_packages.includes(name)) {
+    nodeMetadata.required_packages.push(name);
+  }
+  newPackageName.value = "";
+}
+
+function removePackage(index: number) {
+  nodeMetadata.required_packages.splice(index, 1);
+}
+
 function handlePreview() {
   codeGen.previewCode(nodeMetadata, sections.value, processCode.value);
 }
@@ -349,27 +430,35 @@ const selectedSectionName = computed(() => {
 
 // Insert variable into process code
 function handleInsertVariable(code: string) {
-  // Find the position after "def process..." line to insert the variable
   const lines = processCode.value.split("\n");
   let insertIndex = 1; // Default to after first line
 
-  // Find the first non-empty, non-comment line after the def statement
-  for (let i = 0; i < lines.length; i++) {
-    const trimmed = lines[i].trim();
-    if (trimmed.startsWith("def process")) {
-      insertIndex = i + 1;
-      // Skip any immediate comments after def
-      while (
-        insertIndex < lines.length &&
-        (lines[insertIndex].trim().startsWith("#") || lines[insertIndex].trim() === "")
-      ) {
-        insertIndex++;
+  if (nodeMetadata.use_kernel) {
+    // Kernel mode: insert after initial comments/imports at the top
+    insertIndex = 0;
+    while (
+      insertIndex < lines.length &&
+      (lines[insertIndex].trim().startsWith("#") || lines[insertIndex].trim() === "")
+    ) {
+      insertIndex++;
+    }
+  } else {
+    // Lazy mode: insert after "def process..." line
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (trimmed.startsWith("def process")) {
+        insertIndex = i + 1;
+        while (
+          insertIndex < lines.length &&
+          (lines[insertIndex].trim().startsWith("#") || lines[insertIndex].trim() === "")
+        ) {
+          insertIndex++;
+        }
+        break;
       }
-      break;
     }
   }
 
-  // Insert the variable assignment
   lines.splice(insertIndex, 0, code);
   processCode.value = lines.join("\n");
 }
@@ -478,6 +567,112 @@ function handleInsertVariable(code: string) {
   grid-column: span 2;
 }
 
+/* Kernel Execution */
+.kernel-section {
+  margin-top: 0.75rem;
+  padding: 0.75rem;
+  border: 1px solid var(--border-color, #e0e0e0);
+  border-radius: 6px;
+  background: var(--bg-secondary, #f8f9fa);
+}
+
+.kernel-toggle {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.toggle-label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 0.875rem;
+  font-weight: 500;
+  cursor: pointer;
+}
+
+.kernel-hint {
+  font-size: 0.75rem;
+  color: var(--text-secondary, #6c757d);
+}
+
+.kernel-config {
+  margin-top: 0.75rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid var(--border-color, #e0e0e0);
+}
+
+.field-hint {
+  font-size: 0.7rem;
+  color: var(--text-secondary, #6c757d);
+  margin-top: 0.25rem;
+}
+
+.package-input-row {
+  display: flex;
+  gap: 0.375rem;
+}
+
+.package-input-row .form-input {
+  flex: 1;
+}
+
+.add-package-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 2rem;
+  height: 2rem;
+  padding: 0;
+  background: var(--color-button-primary, #0891b2);
+  color: white;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  flex-shrink: 0;
+}
+
+.add-package-btn:hover {
+  background: var(--color-button-primary-hover, #0e7490);
+}
+
+.package-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.375rem;
+  margin-top: 0.5rem;
+}
+
+.package-tag {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  padding: 0.2rem 0.5rem;
+  background: var(--el-color-primary-light-9, #ecf5ff);
+  color: var(--el-color-primary, #409eff);
+  border-radius: 4px;
+  font-size: 0.8rem;
+}
+
+.remove-tag-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: none;
+  border: none;
+  color: var(--el-color-primary, #409eff);
+  cursor: pointer;
+  font-size: 1rem;
+  line-height: 1;
+  padding: 0 0.125rem;
+  opacity: 0.7;
+}
+
+.remove-tag-btn:hover {
+  opacity: 1;
+  color: var(--el-color-danger, #f56c6c);
+}
+
 /* Sections */
 .sections-area {
   border: 1px solid var(--border-color, #e0e0e0);
diff --git a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/ProcessCodeEditor.vue b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/ProcessCodeEditor.vue
index 3aa0ef964..04f41d550 100644
--- a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/ProcessCodeEditor.vue
+++ b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/ProcessCodeEditor.vue
@@ -1,15 +1,21 @@
 <template>
   <div class="code-editor-section">
     <div class="code-editor-header">
-      <h4>Process Method</h4>
+      <h4>{{ useKernel ? "Kernel Code" : "Process Method" }}</h4>
       <button class="help-btn" title="Show help" @click="showHelp = true">
         <i class="fa-solid fa-circle-question"></i>
         <span>Help</span>
       </button>
     </div>
     <p class="code-hint">
-      Write your data transformation logic. Access settings via
-      <code>self.settings_schema.section_name.component_name.value</code>
+      <template v-if="useKernel">
+        Use <code>flowfile.read_input()</code> and <code>flowfile.publish_output()</code>.
+        Settings are injected as Python variables.
+      </template>
+      <template v-else>
+        Write your data transformation logic. Access settings via
+        <code>self.settings_schema.section_name.component_name.value</code>
+      </template>
     </p>
     <div class="code-editor-wrapper">
       <Codemirror
@@ -37,6 +43,7 @@ import ProcessCodeHelpModal from "./ProcessCodeHelpModal.vue";
 defineProps<{
   modelValue: string;
   extensions: Extension[];
+  useKernel: boolean;
 }>();
 
 const emit = defineEmits<{
diff --git a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/PropertyEditor.vue b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/PropertyEditor.vue
index 5f8f4f06b..2cfe9a80e 100644
--- a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/PropertyEditor.vue
+++ b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/PropertyEditor.vue
@@ -360,7 +360,7 @@
             <i class="fa-solid fa-code"></i>
             Insert Variable
           </button>
-          <span class="field-hint">Add typed variable to process method</span>
+          <span class="field-hint">Add typed variable to code</span>
         </div>
       </div>
 
@@ -380,6 +380,7 @@ import { getComponentIcon } from "./constants";
 const props = defineProps<{
   component: DesignerComponent | null;
   sectionName: string;
+  useKernel?: boolean;
 }>();
 
 const emit = defineEmits<{
@@ -422,11 +423,12 @@ function insertVariable() {
   const sectionName = toSnakeCase(props.sectionName);
   const pyType = getTypeForComponent(props.component.component_type, props.component.multiple);
 
+  const indent = props.useKernel ? "" : "    ";
   let code: string;
   if (props.component.component_type === "SecretSelector") {
-    code = `    ${fieldName}: ${pyType} = self.settings_schema.${sectionName}.${fieldName}.secret_value`;
+    code = `${indent}${fieldName}: ${pyType} = self.settings_schema.${sectionName}.${fieldName}.secret_value`;
   } else {
-    code = `    ${fieldName}: ${pyType} = self.settings_schema.${sectionName}.${fieldName}.value`;
+    code = `${indent}${fieldName}: ${pyType} = self.settings_schema.${sectionName}.${fieldName}.value`;
   }
 
   emit("insert-variable", code);
diff --git a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/composables/useCodeGeneration.ts b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/composables/useCodeGeneration.ts
index 598f3a2d9..57db23d40 100644
--- a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/composables/useCodeGeneration.ts
+++ b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/composables/useCodeGeneration.ts
@@ -135,37 +135,64 @@ export function useCodeGeneration() {
       settingsCode += `    pass\n`;
     }
 
-    // Extract process method body
-    let processBody = processCode;
-    const defMatch = processBody.match(/def\s+process\s*\([^)]*\)\s*->\s*[^:]+:\n?/);
-    if (defMatch) {
-      processBody = processBody.substring(defMatch[0].length);
-    }
+    // Generate node class — kernel vs lazy mode
+    let nodeCode: string;
 
-    // Dedent and re-indent
-    const lines = processBody.split("\n");
-    const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
-    let minIndent = 0;
-    if (nonEmptyLines.length > 0) {
-      minIndent = Math.min(
-        ...nonEmptyLines.map((line) => {
-          const match = line.match(/^(\s*)/);
-          return match ? match[1].length : 0;
-        }),
-      );
-    }
+    if (nodeMetadata.use_kernel) {
+      // Kernel mode: store kernel_code as a triple-quoted string, stub process()
+      const escapedKernelCode = processCode.replace(/\\/g, "\\\\").replace(/"""/g, '\\"\\"\\"');
+      const formattedPackages = nodeMetadata.required_packages
+        .map((p) => `"${p}"`)
+        .join(", ");
+
+      nodeCode = `
 
-    const reindentedLines = lines.map((line) => {
-      if (line.trim().length === 0) {
-        return "";
+class ${nodeName}(CustomNodeBase):
+    node_name: str = "${nodeMetadata.node_name}"
+    node_category: str = "${nodeMetadata.node_category}"
+    node_icon: str = "${nodeMetadata.node_icon || "user-defined-icon.png"}"
+    title: str = "${nodeMetadata.title || nodeMetadata.node_name}"
+    intro: str = "${nodeMetadata.intro || "A custom node for data processing"}"
+    number_of_inputs: int = ${nodeMetadata.number_of_inputs}
+    number_of_outputs: int = ${nodeMetadata.number_of_outputs}
+    use_kernel: bool = True
+    required_packages: list[str] = [${formattedPackages}]
+    kernel_code: str = """${escapedKernelCode}"""
+    settings_schema: ${nodeSettingsName} = ${nodeSettingsName}()
+
+    def process(self, *inputs: pl.DataFrame) -> pl.DataFrame:
+        raise NotImplementedError("This node executes in a kernel")
+`;
+    } else {
+      // Standard lazy mode: extract and re-indent process method body
+      let processBody = processCode;
+      const defMatch = processBody.match(/def\s+process\s*\([^)]*\)\s*->\s*[^:]+:\n?/);
+      if (defMatch) {
+        processBody = processBody.substring(defMatch[0].length);
+      }
+
+      const lines = processBody.split("\n");
+      const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+      let minIndent = 0;
+      if (nonEmptyLines.length > 0) {
+        minIndent = Math.min(
+          ...nonEmptyLines.map((line) => {
+            const match = line.match(/^(\s*)/);
+            return match ? match[1].length : 0;
+          }),
+        );
       }
-      const dedented = line.length >= minIndent ? line.substring(minIndent) : line.trimStart();
-      return "        " + dedented;
-    });
-    processBody = reindentedLines.join("\n");
 
-    // Generate node class
-    const nodeCode = `
+      const reindentedLines = lines.map((line) => {
+        if (line.trim().length === 0) {
+          return "";
+        }
+        const dedented = line.length >= minIndent ? line.substring(minIndent) : line.trimStart();
+        return "        " + dedented;
+      });
+      processBody = reindentedLines.join("\n");
+
+      nodeCode = `
 
 class ${nodeName}(CustomNodeBase):
     node_name: str = "${nodeMetadata.node_name}"
@@ -180,6 +207,7 @@ class ${nodeName}(CustomNodeBase):
     def process(self, *inputs: pl.LazyFrame) -> pl.LazyFrame:
 ${processBody}
 `;
+    }
 
     // Add SecretStr import if SecretStr is used in the process code
     const secretStrImport = processCode.includes("SecretStr")
diff --git a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/composables/useNodeValidation.ts b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/composables/useNodeValidation.ts
index 707cdaad7..44b96e424 100644
--- a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/composables/useNodeValidation.ts
+++ b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/composables/useNodeValidation.ts
@@ -60,11 +60,20 @@ export function useNodeValidation() {
     });
 
     // Validate Python code syntax (basic check)
-    if (!processCode.includes("def process")) {
-      errors.push({ field: "process_code", message: "Process method definition is missing" });
-    }
-    if (!processCode.includes("return")) {
-      errors.push({ field: "process_code", message: "Process method must return a value" });
+    if (nodeMetadata.use_kernel) {
+      if (!processCode.includes("flowfile.publish_output")) {
+        errors.push({
+          field: "process_code",
+          message: "Kernel code must call flowfile.publish_output() to produce output",
+        });
+      }
+    } else {
+      if (!processCode.includes("def process")) {
+        errors.push({ field: "process_code", message: "Process method definition is missing" });
+      }
+      if (!processCode.includes("return")) {
+        errors.push({ field: "process_code", message: "Process method must return a value" });
+      }
     }
 
     return errors;
diff --git a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/constants.ts b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/constants.ts
index 499da7845..894b9f441 100644
--- a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/constants.ts
+++ b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/constants.ts
@@ -29,6 +29,16 @@ export const defaultProcessCode = `def process(self, *inputs: pl.LazyFrame) -> p
 
     return lf`;
 
+/** Default kernel code template */
+export const defaultKernelCode = `# Read input data
+lf = flowfile.read_input()
+
+# Your transformation logic here
+# Example: lf = lf.filter(pl.col("column") > 0)
+
+# Publish output
+flowfile.publish_output(lf)`;
+
 /** Default node metadata */
 export const defaultNodeMetadata = {
   node_name: "",
@@ -38,6 +48,8 @@ export const defaultNodeMetadata = {
   number_of_inputs: 1,
   number_of_outputs: 1,
   node_icon: "user-defined-icon.png",
+  use_kernel: false,
+  required_packages: [] as string[],
 };
 
 /** Get component icon by type */
diff --git a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/types.ts b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/types.ts
index f4cf24df5..066e2aa3d 100644
--- a/flowfile_frontend/src/renderer/app/pages/nodeDesigner/types.ts
+++ b/flowfile_frontend/src/renderer/app/pages/nodeDesigner/types.ts
@@ -64,6 +64,8 @@ export interface NodeMetadata {
   number_of_inputs: number;
   number_of_outputs: number;
   node_icon: string;
+  use_kernel: boolean;
+  required_packages: string[];
 }
 
 /** Available component definition for the palette */
diff --git a/flowfile_frontend/src/renderer/app/types/node.types.ts b/flowfile_frontend/src/renderer/app/types/node.types.ts
index 94d0d2ab4..8245d0644 100644
--- a/flowfile_frontend/src/renderer/app/types/node.types.ts
+++ b/flowfile_frontend/src/renderer/app/types/node.types.ts
@@ -805,6 +805,7 @@ export interface NodeGraphSolver extends NodeSingleInput {
 
 export interface NodeUserDefined extends NodeMultiInput {
   settings: any;
+  kernel_id: string | null;
 }
 
 export interface NodeFormula extends NodeSingleInput {