Algorithms & Data Structures 2
▼
Understands O-notation for TypeScript/JavaScript. Chooses Map vs Object, Set vs Array for optimal complexity. Applies Array.sort with understanding of O(n log n) complexity.
Optimizes algorithms for Electron: list virtualization, debounce/throttle, efficient search. Profiles through Chrome DevTools Performance. Implements efficient tree traversal for file browser.
Conducts algorithmic reviews for Electron projects. Defines performance standards. Mentors on TypeScript optimization.
Shapes algorithmic standards for Electron desktop. Evaluates WASM vs native modules for computation. Defines performance architecture.
Uses TypeScript collections: Array, Map, Set, WeakMap. Works with typed arrays for binary data. Understands JSON serialization for IPC data transfer.
Creates custom data structures for Electron: immutable state (Immer), tree structures for file browser, LRU cache. Uses SharedArrayBuffer for cross-thread data. Works with Protocol Buffers.
Defines data structure standards for the Electron team. Coordinates data layer architecture. Mentors on data structure selection.
Shapes enterprise data structure standards for Electron. Evaluates data layer solutions. Defines data architecture for the organization.
CI/CD 1
▼
Configures GitHub Actions for Electron: build, test, lint. Runs on a single platform. Caches node_modules.
Configures matrix CI for Electron on Windows/Linux/macOS. Automates packaging through electron-builder. Integrates code signing. Publishes artifacts.
Defines CI/CD strategy for the Electron team. Coordinates release automation. Establishes deployment standards.
Shapes enterprise CI/CD standards for Electron. Evaluates CI platforms. Defines build infrastructure.
Clean Code & Refactoring 1
▼
Follows coding standards for TypeScript/Electron. Uses ESLint with TypeScript rules. Configures Prettier for formatting. Goes through code review.
Configures strict TypeScript (strict: true, noUncheckedIndexedAccess). Uses ESLint plugin for Electron security rules. Introduces Husky pre-commit hooks. Applies conventional commits.
Establishes code quality standards for the Electron team. Defines metrics, coordinates tech debt. Introduces quality gates in CI.
Shapes enterprise code quality standards for Electron. Coordinates quality across teams. Defines best practices.
Code Review 1
▼
Participates in code review as a reviewee for TypeScript/Electron. Applies feedback. Understands coding standards.
Conducts code review for TypeScript/Electron. Checks security (IPC safety, CSP), performance, TypeScript correctness. Reviews React components and CSS.
Defines code review process for the team. Establishes review checklist for Electron. Coordinates review workflow.
Shapes enterprise review standards for Electron. Defines review culture. Coordinates cross-team review.
Concurrency & Parallelism 2
▼
Understands async/await in TypeScript for Electron. Handles async IPC through ipcRenderer.invoke. Uses Promise for async operations. Knows the Node.js event loop.
Applies async patterns: Promise.all for parallel operations, AsyncIterator for streaming, AbortController for cancellation. Implements async queue for rate limiting. Handles unhandled rejections.
Defines async strategy for the Electron platform. Establishes async coding standards. Coordinates error handling strategy.
Shapes enterprise async standards for Electron. Evaluates Node.js async evolution. Defines concurrency architecture.
Understands Electron process model: main, renderer, utility processes. Uses Web Workers for offloading computation. Knows Node.js worker_threads at a basic level.
Implements worker_threads for CPU-intensive tasks in main process. Uses SharedArrayBuffer for cross-thread data. Applies UtilityProcess for isolated computation. Manages thread pool.
Defines process model for the Electron platform. Establishes multi-process standards. Coordinates parallel processing strategy.
Shapes enterprise multi-process standards for Electron. Evaluates process model evolution. Defines concurrency architecture.
Cross-Platform Desktop 2
▼
Understands auto-update through electron-updater (autoUpdater). Configures basic update flow with GitHub Releases. Tests updates locally through dev-app-update.yml.
Implements auto-update through electron-updater with S3/generic server. Configures delta updates, staging updates. Shows download progress and release notes in UI. Works with update channels.
Defines update strategy for the Electron product. Coordinates update pipeline with CI/CD. Establishes SLAs for update delivery.
Shapes enterprise update strategy for Electron. Designs centralized update infrastructure. Evaluates enterprise deployment (MDM, SCCM).
Knows packaging basics for Electron: electron-builder, electron-forge. Creates .exe/.dmg/.AppImage. Understands asar archives and their purpose.
Configures electron-builder with custom targets (NSIS, DMG, snap, flatpak). Optimizes bundle size through asar unpacking rules. Signs binaries for Windows (Authenticode) and macOS (Apple Developer ID).
Defines distribution strategy for the Electron product. Coordinates packaging with CI/CD. Establishes signing and notarization standards. Plans store distribution.
Shapes enterprise packaging standards for Electron. Evaluates distribution channels. Designs scalable packaging infrastructure.
Desktop Patterns 2
▼
Understands Electron IPC: ipcMain/ipcRenderer through contextBridge. Implements simple invoke/handle patterns. Uses preload scripts for secure IPC. Passes structured data between processes.
Develops typed IPC through TypeScript interfaces. Implements streaming through MessagePort. Uses SharedArrayBuffer for high-performance data sharing. Manages multiple BrowserWindows through IPC.
Defines IPC strategy for the Electron platform. Establishes IPC patterns and security guidelines. Coordinates cross-process architecture.
Shapes enterprise IPC standards for Electron. Evaluates new IPC approaches (UtilityProcess, WebWorkers). Designs scalable IPC architecture.
Understands MVVM/MVC in the context of Electron + React. Separates components into View and ViewModel (hooks/stores). Uses React Context for state management. Implements data binding through props and state.
Applies state management as ViewModel layer. Organizes navigation through React Router. Implements separation of concerns: IPC layer, business logic, UI components. Tests ViewModel separately.
Defines architectural patterns for the Electron team. Establishes coding guidelines for separation of concerns. Conducts architecture review.
Shapes architectural standards for the organization's Electron development. Evaluates architectural patterns for complex desktop. Defines enterprise architecture guidelines.
Electron & Web-based Desktop 2
▼
Knows Electron 28+ basics: main/renderer processes, BrowserWindow, preload scripts. Creates simple windows with contextBridge. Works with electron-forge for scaffolding. Understands Chromium + Node.js architecture.
Independently develops Electron applications with TypeScript. Manages lifecycle (app events, window management). Configures Tray, Menu, dialog API. Works with protocol handlers and deep links.
Defines technical strategy for Electron development. Establishes security standards (CSP, sandbox). Plans migration between Electron major versions. Coordinates with Chromium/Node.js upgrades.
Defines Electron platform strategy for the organization. Evaluates Electron vs Tauri vs CEF. Shapes enterprise standards for desktop web applications.
Understands security: contextIsolation, nodeIntegration: false. Uses contextBridge for safe API exposure. Avoids eval and remote module. Knows CSP for renderer.
Configures sandbox mode for renderer processes. Implements permission handling (media, geolocation). Validates IPC messages. Configures webRequest for blocking dangerous URLs. Audits npm dependencies.
Defines security strategy for the Electron platform. Establishes security checklist and review process. Coordinates penetration testing and CVE response.
Shapes enterprise security standards for Electron. Evaluates Electron security roadmap. Defines compliance requirements for the organization.
Git & Workflows 1
▼
Uses Git for working with Electron projects. Configures .gitignore for node_modules, dist, build artifacts. Works with branches for features.
Applies Git rebase, cherry-pick, bisect. Configures Git hooks through Husky (lint-staged, type-check). Works with Git LFS for native module binaries. Resolves merge conflicts in package-lock.json.
Defines Git strategy for the Electron team. Establishes branching model. Coordinates release process.
Shapes enterprise Git strategy for Electron. Evaluates monorepo vs polyrepo. Defines Git governance.
Integration Testing 1
▼
Writes integration tests for Electron modules. Tests IPC main↔renderer. Uses Spectron or @electron/testing-library.
Configures integration test environment for Electron. Tests database operations, file system interactions, IPC flows. Uses testcontainers for external dependencies.
Defines integration testing strategy. Coordinates test infrastructure. Establishes integration testing standards.
Shapes enterprise integration testing standards for Electron. Defines test infrastructure strategy.
OOP & Design Patterns 2
▼
Knows patterns in TypeScript/Electron: Observer (EventEmitter), Singleton (main process services), Factory (window creation). Applies Module pattern for IPC handlers.
Implements patterns for Electron: Mediator for IPC, Repository for data access, Strategy for platform-specific code. Applies Builder for complex configuration. Uses Proxy for IPC abstraction.
Defines architectural patterns for the Electron team. Conducts design review. Establishes pattern catalog for desktop development.
Shapes pattern catalog for the organization's Electron desktop. Adapts patterns for TypeScript/Node.js. Publishes best practices.
Understands OOP in TypeScript: classes, interfaces, generics, access modifiers. Uses dependency injection at a basic level. Applies abstractions through interfaces for the service layer.
Designs classes following SOLID in TypeScript. Uses DI through constructor injection (TSyringe/InversifyJS). Applies composition over inheritance. Understands mixins in TypeScript.
Defines OOP standards for the Electron team. Conducts design review. Establishes TypeScript coding guidelines.
Shapes OOP standards for the organization's Electron desktop. Defines the balance between OOP and FP in TypeScript. Consults architects.
React Ecosystem 1
▼
Knows React for Electron renderer: JSX, components, hooks (useState, useEffect). Creates UI components for desktop. Understands React lifecycle in the context of Electron BrowserWindow.
Develops React UI for Electron with TypeScript strict mode. Uses React.lazy for code splitting. Implements virtualization (react-window) for large lists. Applies React.memo and useMemo for optimization.
Defines React standards for the Electron team. Coordinates component library. Establishes React best practices for desktop context.
Shapes enterprise React standards for Electron desktop. Evaluates React evolution for desktop. Defines UI framework strategy.
REST API 1
▼
Uses fetch/axios for REST API from Electron renderer. Calls API through main process for security. Handles HTTP errors and network failures.
Develops API client with retry, timeout, caching through Electron net module. Implements OAuth2/JWT authentication. Uses interceptors for logging and error handling.
Defines API strategy for the Electron product. Coordinates API contracts with backend. Establishes API client standards.
Shapes enterprise API standards for Electron. Evaluates API patterns. Defines API architecture.
State Management 1
▼
Uses React Context and useState for renderer state management. Understands the need for centralized state for multi-window. Works with localStorage/electron-store for persistence.
Applies state management tools. Synchronizes state between main and renderer through IPC. Implements persistence middleware. Works with optimistic updates.
Defines state management strategy for the Electron platform. Establishes state design patterns. Coordinates state architecture across modules.
Shapes enterprise state management standards for Electron. Evaluates state library evolution. Defines data flow architecture.
Unit Testing 1
▼
Writes unit tests through Jest/Vitest for Electron code. Tests renderer components. Tests main process logic separately. Understands IPC mocking.
Structures tests for Electron: main process, renderer, shared. Mocks electron module through jest-electron. Introduces coverage through c8/istanbul. Tests IPC handlers.
Defines testing strategy for the Electron team. Establishes coverage targets. Coordinates test infrastructure.
Shapes enterprise testing standards for Electron. Evaluates testing frameworks. Defines testing maturity model.
Web Frameworks 1
▼
Knows Node.js API for Electron main process: fs, path, crypto, child_process. Uses Express/Fastify for embedded server. Works with node-fetch and native modules.
Develops backend logic through Node.js main: SQLite through better-sqlite3, file watching through chokidar, IPC server. Manages native modules through node-addon-api. Uses Fastify for API.
Defines Node.js strategy for the Electron team. Coordinates native module management. Establishes backend architecture standards.
Shapes enterprise Node.js standards for Electron. Evaluates Node.js LTS strategy. Defines backend architecture for the organization.