┌────────────────────────────────────────────────────────────────────┐
│ @HighMarck17 │
│ independent developer · backend, systems, data, automation │
├────────────┬───────────────────────────────────────────────────────┤
│ building │ backend · systems · automation · agentic workflows │
│ context │ IT consulting and data management in medtech │
│ contact │ [email protected] │
└────────────┴───────────────────────────────────────────────────────┘
I build software: backend services and APIs, desktop tools, automation, and things that run on hardware. Mostly end-to-end, from requirements analysis through to deployment. Professionally I work as an IT consultant and in data management in the medtech sector, in regulated environments where traceability, validation and data integrity are binding requirements rather than good practice. That constraint has shaped how I design systems generally.
A large part of my current work runs through agentic tooling. I use it daily to build, not as an experiment on the side.
building: backend services · APIs · desktop tools · automation
languages: [Python, C++, Rust, SQL, Bash, PowerShell, Java]
also: [PHP, JavaScript, HTML/CSS, VBA]
data_platform: [SQL Server, PostgreSQL, ETL, MES / ERP, Tableau, SAP BusinessObjects WebI]
infrastructure: [Linux, Docker, Nginx, cloud, deployment]
hardware: [Raspberry Pi, Arduino, ESP32, RFID/NFC]
context: IT consulting · data management · regulated medtech
agentic: [Claude Code, OpenCode, MCP, subagents, hooks, skills]
local_models: [Ollama, LM Studio, Qwen, DeepSeek]
currently_learning: [multi-agent orchestration, agent security, applied cryptography]work/
├── backend/
│ ├── services, APIs and system integrations
│ ├── REST APIs and OpenAPI schemas
│ ├── desktop applications and internal tooling
│ ├── MCP servers and tool interfaces for LLM agents
│ ├── web applications (Django, Django REST Framework)
│ ├── database design and SQL development
│ └── testing with pytest
├── automation/
│ ├── scripting in Python, Bash and PowerShell
│ ├── data extraction, scraping and processing pipelines
│ ├── GUI automation and scheduled desktop tasks
│ └── operational workflow optimisation
├── data/
│ ├── integration across heterogeneous systems (MES / ERP)
│ ├── cleansing, validation and traceability
│ ├── ETL
│ └── reporting and dashboards for decision support
├── hardware/
│ ├── C++ on Arduino and ESP32, low-level work on Raspberry Pi GPIO
│ ├── IoT devices: video door entry units, camera links over LAN
│ │ with encrypted transport, environmental and operational monitoring
│ ├── RFID/NFC access control
│ └── serial and network protocols on constrained devices
├── security/
│ ├── applied cryptography in Rust: Signal protocol constructions
│ │ (PQXDH, SPQR, Double Ratchet), post-quantum key exchange
│ ├── hardening public endpoints: rate limiting, CAPTCHA, honeypots,
│ │ disposable-domain filtering, brute-force protection on auth
│ ├── secrets outside the codebase, settings separated per environment
│ ├── wireless and network auditing
│ ├── RF signal analysis, studied some years ago, not current practice
│ └── trust boundaries and permissions in agentic systems
└── systems/
├── Linux, system configuration and deployment
├── containers and reverse proxies (Docker Compose, Nginx, Gunicorn)
├── networking: routing, iptables, NAT, Ethernet bridging and
│ connection sharing across Linux and Windows hosts
└── cloud and connected environments
| Domain | Technologies | |
|---|---|---|
| ◆ | Languages | Python · C++ · Rust · SQL · Bash · PowerShell · Java |
| ◆ | Also | PHP · JavaScript · HTML/CSS · VBA |
| ◆ | Backend | APIs · services · desktop applications · Django · Django REST Framework |
| ◆ | Data / BI | SQL Server · PostgreSQL · ETL · MES / ERP · Tableau · SAP BusinessObjects WebI |
| ◆ | Systems | Linux · Docker · Nginx · networking · cloud · deployment |
| ◆ | Hardware / IoT | Raspberry Pi · Arduino · ESP32 · RFID/NFC · sensors and actuators |
| ◆ | Agent tooling | Claude Code · OpenCode · MCP servers · subagents · hooks · skills |
| ◇ | Orchestration | LangGraph · CrewAI · multi-agent graphs |
| ◆ | Local models | Ollama · LM Studio · Qwen · DeepSeek |
◆ settled, in regular use · ◇ in progress, not consolidated
Most of my work is not public. Client code in regulated environments is not mine to publish, and I keep unaudited cryptographic implementations private on principle. A Signal-protocol implementation nobody has reviewed is a study exercise, not something to hand people as if it were safe.
Most of my current effort goes here, and it is already how I work rather than something I am reading about. I build the tooling as well as use it.
◆ agent harnesses
Claude Code and OpenCode as daily drivers: dynamic workflows,
ultracode (xhigh effort with automatic workflow orchestration),
subagents, path-scoped rules, skills, MCP servers written as the
integration layer between agents and real systems
◆ persistent context architecture
a layered memory system I designed and built for coding agents:
a small always-loaded core, warm and cold layers loaded on demand,
path-scoped reflex rules, a curator subagent for session briefing
and digest, hash-based ratification with drift detection on the core
◆ enforcement over prose
memory files are context, not guarantees: constraints that must
always hold go into PreToolUse hooks, permission denials and
pre-commit checks, not into instructions and good intentions
◆ model selection as a design decision
Local open-weight models are where I started: Ollama and LM Studio
with the Qwen and DeepSeek families, cheap enough to learn the
failure modes on before paying for them. Frontier models do most
of the work now, Opus 5 and Fable 5 for the hard passes and lower
tiers for mechanical fan-out, but local still earns its place.
Some data should not leave the machine at all, and long,
high-volume flows are only affordable when a weaker model is
enough for the work actually being done. Picking the tier is part
of the architecture, not an afterthought
◇ multi-agent orchestration
LangGraph and CrewAI for agent graphs, with human-in-the-loop
supervision treated as a design constraint. Newer ground for me
than the rest of this section
The harness and context work I would call settled. I ship with it. Large multi-agent orchestration is where I am still building the judgement to go with the mechanics.
Studied and applied in parallel. Each of these has ended up in something I was building at the time.
├── LangGraph Academy
├── CrewAI courses
├── Orchestrator Academy
├── advanced Claude Code: workflows, subagents, skills, hooks
├── agent design and orchestration patterns
└── security in agentic workflows: trust boundaries, tool permissions,
prompt injection, least privilege for autonomous agents
Nothing here is theory kept at arm's length: each course has fed into something I was building at the time, and the security material is the part I take most seriously, because autonomous agents with tool access are a real attack surface.
email ▸ [email protected]
github ▸ github.com/HighMarck17