Files
skills/public/hanzo-coursework-fullstack-go-cloud.html
zeekayandHanzo Dev dc9194a5ac Say what runs locally, with a start command that works
skill.md described only the hosted cloud. An outside adopter's agents
vendored it and had to note that its paid-cloud commands did not apply,
and the local lines it did carry did not work: `hanzo up cloud` forwards
to `hanzo host serve`, which needs a cloud binary it does not build, and
`brew install hanzoai/tap/hanzo` installs CLI 1.9.57 against 8.5.158.

"On your own machine" gives one start command each for Base, the cloud,
zip, the MCP server and the engine, each run against current main or the
published package, and lists what only the hosted cloud has. cloud-host
starts from the command that runs and says what `hanzo host serve`,
`hanzo host start` and `hanzo up` expect. app-port and the Go coursework
point at the same commands instead of an invented compose file; llms.txt
opens with the entry, and the site's lede no longer promises a complete
local copy.

Two README commands fail on main, so these pages do not use them: the
cloud's `make dev` stops with `cek: this build cannot encrypt a store`,
and Base's `go install .../examples/base@latest` is refused for its
replace directive.

public/ is regenerated with HIPs from hanzoai/hips main (0eedbe1). The
last build read a working tree, so it served uncommitted HIP edits and
six HIPs that are not on main (1191-1195, 1329); those leave the index,
and their pages stay where they were.

Co-authored-by: Hanzo Dev <[email protected]>
2026-09-11 10:36:35 -07:00

464 lines
24 KiB
HTML

<!doctype html>
<html lang="en"><head>
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>hanzo-coursework-fullstack-go-cloud</title>
<meta name="color-scheme" content="dark">
<style>
/* Committed to one visual world: a dark instrument panel. No light variant —
the dot field and the hairline rules only read on black, and a naive
inversion would wash both out. Every colour is painted explicitly so the page
never borrows a host background. */
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
:root{
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
--font-zen-pixel-square:'Zen Pixel Square',monospace;
--mono:var(--font-zen-mono);
--sans:var(--font-zen-sans);
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
--r:999px; --r-soft:14px;
}
*{box-sizing:border-box}
html{-webkit-text-size-adjust:100%}
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
/* The dot field. A halftone made of one repeating radial-gradient, faded out
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
/* No overflow clip here: the dot field is inset to the box already, and a clip
would cut off the copy-prompt menu. */
.hero{position:relative;border-bottom:1px solid var(--line)}
.hero::before{content:"";position:absolute;inset:0;
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
background-size:7px 7px;
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
pointer-events:none}
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
nav{border-bottom:1px solid var(--line)}
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
justify-content:space-between;align-items:center;gap:1rem}
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--ink);text-decoration:none;
display:inline-flex;align-items:center;gap:.6rem}
.brand i{font-style:normal;color:var(--faint)}
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--soft);text-decoration:none}
nav a.up:hover{color:var(--ink)}
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
h1 em{font-style:normal;color:var(--faint)}
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
line-height:1.2;font-weight:400}
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
.btn.solid:hover{background:#d8d8d4}
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
/* Copy-prompt selector. Each row copies the prompt for its own target. */
.copy{position:relative;display:inline-flex}
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
padding:.4rem;display:flex;flex-direction:column;
box-shadow:0 12px 32px rgba(0,0,0,.75)}
.menu[hidden]{display:none}
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
white-space:nowrap}
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
.mi:hover .mark{color:var(--ink)}
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
letter-spacing:.1em;text-transform:uppercase}
/* Works-with bar: one scrolling row, name and mark per agent. */
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
display:flex;align-items:center}
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
-webkit-overflow-scrolling:touch;
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
.bar::-webkit-scrollbar{display:none}
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
text-decoration:none;background:var(--ground)}
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
.agent .mark{width:.95rem;height:.95rem}
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
p{margin:0 0 1rem;max-width:70ch}
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
li{margin:.22rem 0}
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
text-decoration-color:var(--line-hi)}
a:hover{text-decoration-color:var(--ink)}
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
display:block;overflow-x:auto}
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
.curl{display:block;background:var(--panel);border:1px solid var(--line);
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
white-space:pre;line-height:1.9}
.curl b{color:var(--ink);font-weight:400}
.curl i{font-style:normal;color:var(--faint)}
/* index */
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
#q:focus{outline:none;border-color:var(--soft)}
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
text-transform:uppercase;margin:0 0 2rem}
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
padding-bottom:.45rem}
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
border-radius:var(--r-soft);text-decoration:none}
.row:hover{background:#0a0a0a}
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
color:var(--faint);font-size:.85rem}
footer a{color:var(--soft)}
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
margin:0 0 2rem;font-size:.85rem}
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
border-bottom:1px solid var(--line);padding-bottom:.4rem}
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
.fmap a:hover{text-decoration:underline}
.fmap div{color:var(--faint);line-height:1.5}
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
@media (max-width:640px){
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
.btns{gap:.5rem}
.btn{padding:.75rem 1.15rem;font-size:.68rem}
.copy,.copy .btn{width:100%;justify-content:center}
.menu{left:0;right:0;min-width:0}
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
.strip b{border-right:0;padding-right:0}
.bar{width:100%}
}
</style>
<link rel="alternate" type="text/markdown" href="/hanzo-coursework-fullstack-go-cloud.md">
<link rel="icon" href="/favicon.svg">
<link rel="canonical" href="https://hanzoskills.com/hanzo-coursework-fullstack-go-cloud">
</head>
<!-- Reading this with a machine? Every page here is also plain markdown.
This one: https://hanzoskills.com/hanzo-coursework-fullstack-go-cloud.md
Index: https://hanzoskills.com/llms.txt
Corpus: https://hanzoskills.com/all.md
Append .md to any path for the markdown twin. -->
<body>
<nav><div class="in">
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
<a class="up" href="/">All skills</a>
</div></nav>
<div class="wrap">
<h1>hanzo-coursework-fullstack-go-cloud</h1><p class="lede">This coursework trains engineering teams migrating from slow, interpreted, memory-heavy environments (Python, Next.js, Node.js, Ruby on Rails) to Hanzo&#x27;s high-performance native stack (Go, Rust, C++).</p><h1>Coursework: Fullstack Cloud Engineering with Go &amp; Hanzo Base</h1>
<p><strong>Category</strong>: Hanzo Ecosystem &amp; Engineering Curriculum <strong>Level</strong>: Intermediate to Advanced <strong>Prerequisites</strong>: Familiarity with web services, basic understanding of concurrency. <strong>Related Skills</strong>: <code>hanzo/hanzo-migrate-backend-to-go.md</code>, <code>hanzo/hanzo-base.md</code>, <code>hanzo/hanzo-cloud.md</code>, <code>hanzo/hanzo-tutorial-realtime-sse-backend.md</code>, <code>hanzo/hanzo-examples-native-cloud.md</code></p>
<hr>
<h2>Curriculum Overview</h2>
<p>This coursework trains engineering teams migrating from slow, interpreted, memory-heavy environments (Python, Next.js, Node.js, Ruby on Rails) to Hanzo&#x27;s high-performance native stack (<strong>Go, Rust, C++</strong>).</p>
<pre><code>┌─────────────────────────────────────────────────────────────────────────────┐
│ CURRICULUM: FULLSTACK CLOUD ENGINEERING WITH GO │
│ │
│ [MODULE 1] Architectural Foundations &amp; Runtime Shift │
│ - Why native compiled code wins: Go, Rust &amp; C++ │
│ - Benchmarking: 15ms cold starts vs 6s Next.js SSR │
│ │
│ [MODULE 2] Running Your Own Cloud Locally │
│ - Base and the open-source cloud, from a checkout │
│ - start commands: skill.md, On your own machine │
│ │
│ [MODULE 3] Realtime SSE Streaming &amp; State Synchronization │
│ - Native Server-Sent Events (SSE) in Go │
│ - Zero-overhead streaming without Pusher / external SaaS │
│ │
│ [MODULE 4] Extending Hanzo Cloud with `/v1/*` Subsystems │
│ - Plugin host architecture &amp; ZAP binary transport (HIP-0114) │
│ - Wiring routes in `manifest/apps.go` │
│ │
│ [MODULE 5] Production Observability, Storage &amp; Deployment │
│ - Embedded SQLite + ClickHouse datastore hybrid │
│ - Zero-dependency static binary deployments (`CGO_ENABLED=0`) │
└─────────────────────────────────────────────────────────────────────────────┘</code></pre>
<hr>
<h2>Module 1: The Runtime Shift (Python/Next.js to Native Go)</h2>
<h3>1.1 The Cost of Interpreted Runtimes</h3>
<p>Interpreted runtimes impose hidden taxes in enterprise environments:</p>
<ul><li><strong>Python</strong>: The Global Interpreter Lock (GIL) serializes threads; async runtimes (<code>asyncio</code>) suffer from event-loop starvation and heavy memory fragmentation.</li><li><strong>Node.js / Next.js</strong>: Gigabytes of <code>node_modules</code>, cold start latencies (1.5s - 8s), high idle footprint (250MB+ per SSR container), and fragile build tooling.</li><li><strong>Java / Spring</strong>: High JVM memory overhead and slow warmup periods.</li></ul>
<h3>1.2 The Hanzo Triad</h3>
<ol><li><strong>Go (<code>github.com/hanzoai/base</code>, <code>github.com/hanzoai/cloud</code>)</strong>:</li></ol>
<ul><li>Compiles to a single static binary (<code>CGO_ENABLED=0</code>).</li><li>Memory footprint: ~15MB idle.</li><li>Concurrency: Goroutines scheduled on <code>M:N</code> runtime with non-blocking network pollers.</li></ul>
<ol><li><strong>Rust (<code>hanzoai/engine</code>, <code>hanzoai/reth</code>)</strong>:</li></ol>
<ul><li>Zero-cost abstractions, deterministic memory safety without GC pauses.</li><li>Inference execution and cryptographic settlement.</li></ul>
<ol><li><strong>C++ (Metal, CUDA, ANE)</strong>:</li></ol>
<ul><li>Bare-metal hardware kernels for Apple Silicon and NVIDIA tensor cores.</li></ul>
<h3>1.3 Lab 1: Profiling Memory &amp; Cold Starts</h3>
<p>Compare a basic Next.js / FastAPI endpoint against a Go Hanzo Base endpoint:</p>
<pre><code class="lang-bash"># Build Go binary statically
CGO_ENABLED=0 go build -ldflags=&quot;-s -w&quot; -o ./bin/server ./main.go
# Inspect size and launch time
ls -lh ./bin/server
time ./bin/server --healthcheck</code></pre>
<p><em>Expected Result</em>: Binary size &lt; 25MB, startup time &lt; 15 milliseconds.</p>
<hr>
<h2>Module 2: Run It Locally</h2>
<p>Base and the open-source cloud start from a checkout, with no account.</p>
<h3>The Philosophy</h3>
<p>Never mock third-party cloud APIs. Run the actual Hanzo services in-process.</p>
<h3>Lab 2: Launch &amp; Healthcheck</h3>
<pre><code class="lang-bash"># Base, in a checkout of github.com/hanzoai/base
go run ./examples/base serve
curl -i http://127.0.0.1:8090/v1/health # from a second terminal
# the cloud, in a checkout of github.com/hanzoai/cloud
make build &amp;&amp; CLOUD_DEV_UNENCRYPTED=1 CLOUD_LISTEN=127.0.0.1:8080 CLOUD_DATA_DIR=.dev/data ./cloud
curl -s http://127.0.0.1:8080/v1/openapi.json # from a second terminal</code></pre>
<p>The cloud runs unencrypted this way, for local development only. Every part that runs locally, and what needs the hosted cloud, is in <code>skill.md</code> under <em>On your own machine</em>.</p>
<hr>
<h2>Module 3: Realtime Native SSE (Server-Sent Events)</h2>
<h3>3.1 Why Native SSE Over WebSockets?</h3>
<ul><li>Built directly on HTTP/1.1 and HTTP/2 (RFC 8895).</li><li>Automatic browser reconnection via <code>Last-Event-ID</code>.</li><li>Zero firewall or proxy websocket-upgrade friction.</li><li>Efficient unidirectional event delivery for LLM tokens, notifications, and analytics.</li></ul>
<h3>3.2 Implementing the Hub in Go</h3>
<p>A lock-free, concurrent SSE multiplexer:</p>
<pre><code class="lang-go">package realtime
import (
&quot;fmt&quot;
&quot;net/http&quot;
&quot;sync&quot;
&quot;time&quot;
)
type Event struct {
ID string
Event string
Data []byte
}
type Hub struct {
mu sync.RWMutex
clients map[chan Event]struct{}
}
func NewHub() *Hub {
return &amp;Hub{
clients: make(map[chan Event]struct{}),
}
}
func (h *Hub) Subscribe() chan Event {
ch := make(chan Event, 64)
h.mu.Lock()
h.clients[ch] = struct{}{}
h.mu.Unlock()
return ch
}
func (h *Hub) Unsubscribe(ch chan Event) {
h.mu.Lock()
delete(h.clients, ch)
close(ch)
h.mu.Unlock()
}
func (h *Hub) Broadcast(e Event) {
h.mu.RLock()
defer h.mu.RUnlock()
for ch := range h.clients {
select {
case ch &lt;- e:
default:
// Client channel full; drop or handle slow consumer
}
}
}
func (h *Hub) Handler() http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
flusher, ok := w.(http.Flusher)
if !ok {
http.Error(w, &quot;Streaming unsupported&quot;, http.StatusInternalServerError)
return
}
w.Header().Set(&quot;Content-Type&quot;, &quot;text/event-stream&quot;)
w.Header().Set(&quot;Cache-Control&quot;, &quot;no-cache&quot;)
w.Header().Set(&quot;Connection&quot;, &quot;keep-alive&quot;)
w.Header().Set(&quot;X-Accel-Buffering&quot;, &quot;no&quot;)
ch := h.Subscribe()
defer h.Unsubscribe(ch)
ticker := time.NewTicker(15 * time.Second)
defer ticker.Stop()
for {
select {
case &lt;-r.Context().Done():
return
case &lt;-ticker.C:
fmt.Fprintf(w, &quot;: heartbeat\n\n&quot;)
flusher.Flush()
case e := &lt;-ch:
if e.ID != &quot;&quot; {
fmt.Fprintf(w, &quot;id: %s\n&quot;, e.ID)
}
if e.Event != &quot;&quot; {
fmt.Fprintf(w, &quot;event: %s\n&quot;, e.Event)
}
fmt.Fprintf(w, &quot;data: %s\n\n&quot;, e.Data)
flusher.Flush()
}
}
}
}</code></pre>
<h3>3.3 Lab 3: Verifying SSE Streams with cURL</h3>
<pre><code class="lang-bash"># Listen to live stream
curl -N http://localhost:8090/v1/events/stream</code></pre>
<hr>
<h2>Module 4: Extending Hanzo Cloud with <code>/v1/*</code> Subsystems</h2>
<p>Hanzo Cloud (<code>hanzoai/cloud</code>) uses a host + plugin registry architecture connected via <strong>ZAP Transport</strong> (HIP-0114).</p>
<h3>4.1 Subsystem Interface</h3>
<p>Every subsystem implements <code>cloud.Plugin</code>:</p>
<pre><code class="lang-go">package custom
import (
&quot;net/http&quot;
&quot;github.com/hanzoai/cloud&quot;
)
func init() {
cloud.Register(&quot;analytics-custom&quot;, NewPlugin)
}
type Plugin struct{}
func NewPlugin(cfg *cloud.Config) (cloud.Plugin, error) {
return &amp;Plugin{}, nil
}
func (p *Plugin) Mount(mux *http.ServeMux) {
mux.HandleFunc(&quot;POST /v1/custom/ingest&quot;, p.HandleIngest)
mux.HandleFunc(&quot;GET /v1/custom/stats&quot;, p.HandleStats)
}
func (p *Plugin) HandleIngest(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusAccepted)
w.Write([]byte(`{&quot;status&quot;:&quot;queued&quot;}`))
}
func (p *Plugin) HandleStats(w http.ResponseWriter, r *http.Request) {
w.Header().Set(&quot;Content-Type&quot;, &quot;application/json&quot;)
w.Write([]byte(`{&quot;active_workers&quot;:16,&quot;throughput_per_sec&quot;:124000}`))
}</code></pre>
<hr>
<h2>Module 5: Storage &amp; Observability</h2>
<h3>5.1 Hybrid Storage</h3>
<ul><li><strong>Transactional State</strong>: Embedded SQLite (<code>modernc.org/sqlite</code>) for single-binary zero-dependency nodes or PostgreSQL (<code>pgx/v5</code>).</li><li><strong>Telemetry &amp; Logs</strong>: Columnar ClickHouse datastore.</li></ul>
<h3>5.2 Test-Driven Development (TDD)</h3>
<p>Every module must ship with automated tests proving correctness:</p>
<pre><code class="lang-go">// hub_test.go
package realtime_test
import (
&quot;context&quot;
&quot;net/http&quot;
&quot;net/http/httptest&quot;
&quot;testing&quot;
&quot;time&quot;
&quot;github.com/hanzoai/base/realtime&quot;
)
func TestSSEHub(t *testing.T) {
hub := realtime.NewHub()
server := httptest.NewServer(hub.Handler())
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
req, _ := http.NewRequestWithContext(ctx, &quot;GET&quot;, server.URL, nil)
resp, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatalf(&quot;Failed to connect to SSE stream: %v&quot;, err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Errorf(&quot;Expected status 200, got %d&quot;, resp.StatusCode)
}
if ct := resp.Header.Get(&quot;Content-Type&quot;); ct != &quot;text/event-stream&quot; {
t.Errorf(&quot;Expected Content-Type text/event-stream, got %s&quot;, ct)
}
}</code></pre>
<hr>
<h2>Conclusion &amp; Certification</h2>
<p>By completing this coursework, your engineering team possesses the patterns, tooling, and architectural foundation to:</p>
<ol><li>Eliminate legacy interpreted runtimes in favor of compiled Go and Rust.</li><li>Build and run offline-ready local cloud environments.</li><li>Stream realtime data natively via SSE.</li><li>Scale seamlessly against Hanzo AI Cloud (<code>hanzo.ai</code> and <code>api.hanzo.ai</code>).</li></ol>
<footer>
<div class="fmap">
<div><b>Build</b>
<a href="https://hanzo.app">hanzo.app</a> app builder
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
<div><b>Run</b>
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
<div><b>Account</b>
<a href="https://hanzo.id">hanzo.id</a> sign in
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
<div><b>Company</b>
<a href="https://hanzo.ai">hanzo.ai</a> canonical
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
</div>
<div class="fend"><a href="/hanzo-coursework-fullstack-go-cloud.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
</footer>
</div></body></html>