Portfolio / 2026Computer EngineeringMcAllen, Texas

Computer Engineering · UTRGV · McAllen, Texas

Full-stack products, AI systems, and interfaces with a point of view.

I’m Jose Carlos Arce Camet, a Computer Engineering student building complete software products across AI, audio, finance, workflow systems, and interaction-heavy frontend experiences.

My work combines technical architecture, secure user-owned data, accessibility, testing, and original product design.

Seeking software engineering, full-stack, and AI application opportunities.

01Selected work / eight systems

Different products. One engineering practice.

Each project isolates a different kind of risk—from AI context and audio validation to financial correctness, workflow modeling, and keyboard interaction, down to storage durability, process control, and sensor-fault handling.

04Workflow softwareLive
Conceptual Intern Hunt CRM dashboard study with pipeline totals, status distribution, deadlines, and funnel statistics.
Interface studyInterface study — conceptual dashboard composition

Business workflow modeling

Intern Hunt CRM

A private recruiting pipeline for applications, follow-ups, and interview milestones.

A Supabase-backed job-search workspace for managing opportunities, recruiter context, deadlines, activity history, and pipeline analytics.

  • React
  • TypeScript
  • Supabase
  • PostgreSQL
  • TanStack Query
  • Tailwind CSS
  • Full application lifecycle
  • Recruiter and follow-up context
  • Supabase Row Level Security
  • Smart views and analytics
05Interactive frontendLive
Rose Court chess-piece study showing original light and dark pieces at board, silhouette, and interaction scales.
Product captureOriginal Rose Court piece system

Accessible interaction

Local Matchroom

Accessible local chess built on a replayable move-log architecture.

A local two-player chess interface with complete legal-move integration, SAN history, keyboard interaction, responsive geometry, and original SVG pieces.

  • React
  • TypeScript
  • chess.js
  • Vite
  • Tailwind CSS
  • Vitest
  • Replayable canonical state
  • Complete rules integration
  • ARIA grid interaction
  • Focus-managed promotion
06Systems softwareSource published
RustKV system diagram showing a client sending framed TCP requests to a connection thread, codec, and executor that share a database of an RwLock store, a Mutex append log, and atomic metrics backed by disk.
System diagramRequest path from TCP frame to durable log

Durability and concurrency

RustKV

A persistent key-value server in Rust with a bounded binary protocol and crash-conscious storage.

A single-node TCP key-value service with concurrent clients, synchronized shared state, TTLs, a CRC32 append-only log, restart replay, compaction, and structured metrics.

  • Rust
  • TCP sockets
  • Arc / RwLock / Mutex
  • CRC32
  • tracing
  • Criterion
  • Bounded binary TCP protocol
  • CRC32 append-only log
  • Torn-tail repair on restart
  • Crash-conscious compaction
07Systems softwareSource published
ArcShell system diagram showing a raw input line flowing through tokenize and parse_line into a pipeline, then either run_builtin in the shell process or execute_pipeline with fork, dup2, and execvp per stage.
System diagramParser to executor flow

Process control

ArcShell

A small POSIX shell in C built directly on fork, exec, pipes, and signals.

A deliberately small shell that implements pipelines, redirection, background jobs, zombie-free reaping, and a defensible signal model from raw process-control syscalls.

  • C
  • POSIX
  • Linux / WSL2
  • gcc
  • Make
  • ASan / UBSan
  • Multi-stage pipelines
  • Redirection < > >>
  • Zombie-free child reaping
  • Shell survives Ctrl-C
08Embedded systemsIn progress
ThermalGuard design diagram showing sensors feeding firmware glue and an fw_logic state machine that drives a fan and alarm, a Rust harness on USB serial, and evidence tiers with firmware logic and host mock passing and real hardware not started.
System diagramDesign diagram and evidence tiers

Fault-tolerant control logic

ThermalGuard

Fault-tolerant cooling-controller firmware for the Arduino Mega 2560, with verified control logic and hardware bring-up still ahead.

An in-progress embedded controller with dual temperature sensors, an asymmetric fault-handling state machine, and a line-based serial protocol. The firmware logic and host harness are verified in software; no physical hardware bring-up has happened yet.

  • C++
  • Arduino Mega 2560
  • Rust
  • CMake
  • GitHub Actions
  • In progress — no hardware bring-up yet
  • Firmware logic: 50/50 native checks
  • Host harness: 13/13 Rust tests
  • Four-state fault FSM
02Demonstrated capabilities

What the work proves.

Capabilities are grouped by engineering responsibility, not presented as a wall of logos.

01

AI application engineering

Explicit orchestration and bounded context instead of opaque behavior.

  • Deterministic orchestration
  • Context construction
  • Approval-gated memory
  • Document retrieval
  • Provider integration
  • Evaluation and fallback behavior
02

Full-stack development

Complete workflows across interface, API, persistence, and ownership boundaries.

  • React and TypeScript
  • Fastify APIs
  • PostgreSQL and Prisma
  • Supabase
  • Authentication
  • User-owned data
03

Frontend engineering

Interfaces built around complex state, clarity, and accessible interaction.

  • Responsive systems
  • Complex state
  • Accessible forms
  • Keyboard interaction
  • Data visualization
  • Original component design
04

Security and reliability

Authorization, validation, and failure modes treated as product concerns.

  • Row Level Security
  • Session security
  • Upload validation
  • Ownership boundaries
  • Rate and concurrency controls
  • Defensive failure handling
05

Testing and delivery

Risk-focused verification from pure logic through real-browser behavior.

  • Vitest
  • React Testing Library
  • Playwright
  • GitHub Actions
  • Migration verification
  • Accessibility validation
03 / Working principles

The interface is only the visible edge of the system.

  1. 01

    Model the system before styling the screen.

  2. 02

    Treat user ownership as a backend responsibility.

  3. 03

    Make uncertain behavior inspectable.

  4. 04

    Use design to clarify—not obscure—the product.

04About the practice

System boundaries first.

I build the complete workflow—and stay responsible for the details.

I’m a Computer Engineering student at UTRGV with a software-focused project portfolio spanning AI systems, browser audio, finance tools, operational dashboards, and accessible interfaces.

I’m especially interested in full-stack product engineering: translating an idea into a working system, defining its data and trust boundaries, and refining the experience until it feels deliberate.

More about my process
Education
The University of Texas Rio Grande Valley
Degree
Bachelor of Science in Computer Engineering
Expected
Fall 2027
Languages
English / Spanish
05 / Start a conversation

Building something that needs product judgment and technical follow-through?

I’m open to software-engineering internships, junior development opportunities, remote or hybrid technical work, and selected freelance projects.