S
Web App2026CompletedFeatured Project

Skillkeys

Production-grade Web App software engineering system implemented in TypeScript. Features a decoupled multi-tier architecture with validated API endpoints and resilient state processing. **Portfolio CMS Admin Panel** is a desktop‑first content management system that abstracts away hard‑coded updates for a personal portfolio. It combines an Electron shell with a modern web stack—`React 18`, `Next.js` (App Router), `TypeScript`, `TailwindCSS`, and **Shadcn UI**—to deliver a native‑like experience while retaining web flexibility. The backend runs on `Express` with `MongoDB`, secured by `Helmet`, rate‑limiting, and strict `Joi` validation, ensuring safe data persistence and API delivery to the public‑facing site.

RoleSole Developer
Classificationhigh
Client / ContextOpen Source Project
Development TimelineCompleted

Technical Architecture & Engineering Overview

Detailed system design and core implementation

The system follows a client‑server architecture where the Electron main process hosts a bundled Next.js renderer. The frontend is compiled with Vite for rapid hot‑module replacement and leverages React Server Components where appropriate. State is managed globally via a custom useStore hook, enabling seamless navigation between configuration, practice, and results pages while persisting user preferences in localStorage via a reusable hook.

Data ingestion occurs through a set of RESTful endpoints (e.g., /api/projects, /api/messages) that accept JSON payloads validated against Joi schemas before being written to MongoDB collections. Rich text content created with Tiptap is sanitized on the server to prevent XSS, then stored as HTML strings and re‑hydrated on the public portfolio without loss of formatting.

Security guardrails include Helmet headers, rate limiting middleware, and JWT‑based authentication for admin routes. All API responses are typed with TypeScript interfaces, and the backend enforces strict validation to avoid malformed data reaching the database.

The build topology uses Electron‑builder to package the app for Linux and Windows, while the web assets are output by Vite into the Electron renderer. Continuous integration scripts (not shown) handle linting with ESLint, type‑checking, and automated MongoDB backup utilities that export collections on a schedule.

System Diagrams & Flow Visualizations

Interactive Mermaid architecture & execution flows

Architectural Visualizer · System Architecture

Core System Features

Key capabilities & architectural features

FEATURE 01

Desktop‑first deployment via Electron for Linux and Windows

Desktop‑first deployment via Electron for Linux and Windows

FEATURE 02

Dark‑mode UI built with TailwindCSS and Shadcn UI

Dark‑mode UI built with TailwindCSS and Shadcn UI

FEATURE 03

Rich‑text editing with Tiptap and server‑side sanitization

Rich‑text editing with Tiptap and server‑side sanitization

FEATURE 04

Drag‑and‑drop ordering of projects, skills, and testimonials using dnd-kit

Drag‑and‑drop ordering of projects, skills, and testimonials using dnd-kit

FEATURE 05

Real‑time form validation powered by Joi schemas

Real‑time form validation powered by Joi schemas

FEATURE 06

Secure admin API with Helmet headers and rate limiting

Secure admin API with Helmet headers and rate limiting

FEATURE 07

Global state management with a custom Zustand store

Global state management with a custom Zustand store

FEATURE 08

Persistent user settings via a `useLocalStorage` hook

Persistent user settings via a `useLocalStorage` hook

FEATURE 09

Message inbox for handling contact form submissions

Message inbox for handling contact form submissions

FEATURE 010

GitHub and Pinterest integration modules for dynamic content

GitHub and Pinterest integration modules for dynamic content

Engineering Challenges & Solutions

Problem statements & resolution strategies

Challenge #1

Balancing native performance of Electron with the overhead of bundling a full Next.js app required careful asset optimization and lazy loading strategies.

Balancing native performance of Electron with the overhead of bundling a full Next.js app required careful asset optimization and lazy loading strategies.

Challenge #2

Ensuring XSS safety while storing raw HTML from Tiptap demanded a robust sanitization pipeline and thorough testing across browsers.

Ensuring XSS safety while storing raw HTML from Tiptap demanded a robust sanitization pipeline and thorough testing across browsers.

Challenge #3

Synchronizing rapid drag‑and‑drop reorder actions with MongoDB sequence indices introduced race conditions that were mitigated with optimistic concurrency checks.

Synchronizing rapid drag‑and‑drop reorder actions with MongoDB sequence indices introduced race conditions that were mitigated with optimistic concurrency checks.

Challenge #4

Managing global state across multiple pages without causing unnecessary re‑renders forced a lean Zustand store design and selective subscription patterns.

Managing global state across multiple pages without causing unnecessary re‑renders forced a lean Zustand store design and selective subscription patterns.

Challenge #5

Packaging the Express server inside Electron raised concerns about port conflicts and process lifecycle management, solved by using IPC instead of network sockets.

Packaging the Express server inside Electron raised concerns about port conflicts and process lifecycle management, solved by using IPC instead of network sockets.

Key Code Modules & Architecture

Core file entrypoints and service responsibilities

AppMODULE 01
app

Module component managing app source logic

ComponentsMODULE 02
components

Module component managing components source logic

UiMODULE 03
components/ui

Module component managing ui source logic

LibMODULE 04
lib

Module component managing lib source logic

StoreMODULE 05
store

Module component managing store source logic

User Journey Pipeline

  1. 1User Access & Preset Selection: User opens client interface and configures request parameters or task workflow presets.
  2. 2Client Payload Dispatch: Front-end components (React, Next.js, TailwindCSS) serialize input objects and send HTTP/WebSocket requests to `/api/analyze`.
  3. 3Middleware & Validation Check: API Gateway evaluates CORS headers, authorization tokens, and input validation schemas.
  4. 4Service & Inference Execution: Service controllers dispatch request frames to model inference engine (Local Engine) or storage layer.
  5. 5Response Delivery & State Synchronization: Serialized output payload is returned to the client and rendered in the visual workspace.

Execution Code Flow

  1. 1Entrypoint Invocation: Request enters network interface layer via `POST /api/analyze`.
  2. 2Schema & Guardrail Verification: Middleware sanitizes payload parameters and checks rate-limiting limits.
  3. 3Controller Dispatch: Router delegates validated object to `App` service controller.
  4. 4Engine Execution & Storage Operations: Controller executes business logic, queries database models (Persistence), and invokes ML workers.
  5. 5Response Serialization: Result model is formatted into standard JSON response frame and delivered with HTTP 200 OK.

System FAQ & Technical Specifications

Frequently asked questions and core architecture details

Q: What technologies are used in Skillkeys?

Skillkeys is engineered using modern full-stack frameworks.

Q: What core engineering problem does Skillkeys solve?

Production-grade Web App software engineering system implemented in TypeScript. Features a decoupled multi-tier architecture with validated API endpoints and resilient state processing. **Portfolio CMS Admin Panel** is a desktop‑first content management system that abstracts away hard‑coded updates for a personal portfolio. It combines an Electron shell with a modern web stack—`React 18`, `Next.js` (App Router), `TypeScript`, `TailwindCSS`, and **Shadcn UI**—to deliver a native‑like experience while retaining web flexibility. The backend runs on `Express` with `MongoDB`, secured by `Helmet`, rate‑limiting, and strict `Joi` validation, ensuring safe data persistence and API delivery to the public‑facing site.

Q: How is 'Balancing native performance of Electron with the overhead of bundling a full Next.js app required careful asset optimization and lazy loading strategies.' resolved in Skillkeys?

Resolved through specialized system architecture and resilient state handling.

Related Systems & Case Studies

Explore similar technical architectures and projects

View All Systems