Neuromorphic Inference Lab
Case Study • Live Docs + Source Code

EdgePulse

A production-minded reference system for operational AI: edge ingest → storage → scheduled ML scoring → alerting → dashboard. This page is the “live documentation” on the domain; the repository is the exact implementation.

Problem

  • Edge/field data arrives continuously, often noisy or incomplete.
  • You need reliable storage + traceability, not just a notebook.
  • Scoring must run on schedule (or triggers) with predictable cost.
  • Alerts and dashboards must be actionable and auditable.
View Source (GitHub) Evidence Index Back to Demos
Architecture MLOps Metrics How to verify

Solution

EdgePulse focuses on “operational readiness”: stable ingestion, storage, scheduled scoring jobs, alerting, and a lightweight dashboard view. The goal is not just “a model”, but a system you can run, monitor, and evolve.

Key capabilities

  • Ingestion pipeline with validation and traceability.
  • Central storage as system-of-record (data lineage).
  • Scheduled scoring jobs (batch/near-real-time pattern).
  • Alerting workflow (thresholds + context).
  • Dashboard-ready outputs (for ops + analysts).

Neuromorphic angle (without the academia trap)

  • Efficiency-first inference: cost/latency trade-offs are explicit.
  • Robustness under imperfect inputs and operational constraints.
  • Observability as a first-class requirement (not an afterthought).

Architecture

This is the conceptual flow (high level). We’ll refine with a real diagram later; this is already good enough for recruiter comprehension and technical interviews.

[Edge / Field Sources] | v [Ingestion API / Collector] ---> [Validation + Normalization] | v [System of Record: Storage (SQL)] | +--> [Scheduled Scoring Job] ---> [Scored Outputs] | | | v | [Alerting Rules] ---> [Notifications] | v [Dashboard / Views] (Ops + Analyst friendly)
Repo: edgepulse Next: MLOps

MLOps & Operability

What’s included

  • Reproducible runs (config + deterministic pipeline behavior where possible).
  • Container-first packaging (portable execution environment).
  • Clear separation: ingest / scoring / alerting / views.
  • Documentation as product: this page + README in repo.

What we’ll add next

  • CI checks and release tags for “build provenance”.
  • Basic monitoring: job success rate, runtime, data quality signals.
  • One-click local run instructions (compose / scripts) surfaced in the repo.

Metrics

This section is intentionally written to be “fillable” as you mature the system. Start with a baseline (even manual), then automate.

System metrics

  • Ingestion throughput (events/min) and error rate.
  • Job runtime (p50/p95) and success rate.
  • End-to-end latency (ingest → available in dashboard).
  • Cost proxy (if deployed) per day / per run.

Model metrics

  • Baseline performance (e.g., accuracy/AUC or anomaly hit-rate).
  • Stability over time (drift indicators).
  • Calibration / confidence behavior (where relevant).

How to verify (fast audit)

Recruiter/engineer should be able to audit you in 2 minutes. This is the exact path we want them to follow.

  1. Open the repository: github.com/nepryoon/edgepulse
  2. Read README: architecture + how to run locally.
  3. Check that the system is container-friendly and the pieces are separated (ingest/scoring/alerting).
  4. Return to Evidence Index to map skills → proofs.
Evidence: Docker Evidence: SQL Evidence: AWS Evidence: CI/CD