Skip to main content
    Norditco logo
    All engineering posts
    Published April 7, 2026Norditco Engineering

    Hybrid Ops - Work Board, Workflow Glue, and an AI Inbox as the Company Operating System

    • operations
    • architecture
    • automation

    Norditco ships a language-learning app, a writing tool, a text-to-speech service, and the hub you are reading this on. Those products share one production host and a deliberate operating model: humans and agents plan on a control plane; production only runs what a person has approved.

    AI agents are good at the routine half of operations: summarizing state, filing tasks, preparing a deploy, drafting a post-incident note. They are also exactly the kind of actor you do not want holding unsupervised root on a production host. So the question we kept returning to was not "how do we automate operations" but "where does the control plane live, and who is allowed to press the button that changes production?"

    This post describes the operating model we settled on. It has three pieces: a hosted work board as the source of truth, an AI inbox as the channel between humans and agents, and a human approval step wired to a small, allowlisted executor on the production server. The planning and orchestration brain stays off that server. The server only executes what a person has approved.

    It is a description of architecture and policy. Hostnames, credentials, and exact commands stay in our private ops repository.

    The problem with putting the brain on the server

    The tempting design for a one-server company is to put everything on the server. Run the workflow engine there, run the agent tooling there, give it a shell, and let it manage itself. It is simple, it is close to the thing being managed, and it works on the first demo.

    It fails for three reasons that compound.

    Memory is the scarce resource. Our production host has a little under 2 GiB of RAM, and that budget already belongs to customer-facing workloads. A workflow engine with a database, a browser-based editor, and a handful of integrations is not free. Every megabyte it takes is a megabyte a product does not get. We wrote about the footprint work in Keeping a Single VPS Reliable, and the lesson from it applies here too. Operations tooling should not compete with the product for the same few hundred megabytes.

    Blast radius follows location. If the system that decides what to change also lives on the machine being changed, a bug in the decision layer is a bug on production. A confused agent, a bad workflow edit, or a leaked automation credential all land in the same place. Separating where decisions are made from where actions are executed gives you a seam to put policy on.

    Auditability gets muddy. When planner and executor share a host, "what did we intend" and "what actually ran" blur together. We wanted intent to be a durable record that exists before execution.

    So we split the system into two planes.

    Two planes

    The control plane is where work is planned, discussed, and prepared. It runs on a developer laptop and on hosted SaaS. The production plane is where customer traffic is served. It runs on the VPS. The two meet at one narrow interface.

    Architecture diagram. Expand for a larger view with zoom.

    A few properties of this layout matter more than the boxes themselves.

    • Everything heavy lives on the left. Planning, agent reasoning, workflow editing, and long-form documentation never run on the production host.
    • The right side is deliberately dull. The VPS runs an executor that knows a fixed list of verbs, plus a thin messaging bridge that relays human decisions to it. There is no language model on the server and no general-purpose automation runtime.
    • The only path from left to right crosses a human. An agent can propose. It cannot approve its own proposal.

    We call this a hybrid model because neither half is sufficient alone. A laptop-only setup cannot respond when the laptop is closed. A server-only setup puts the brain on production. The hybrid keeps durable state in hosted tools, keeps heavy compute on the laptop, and keeps a minimal, auditable actuator on the server.

    The work board as source of truth

    We use one hosted project board as the single place where work is defined and its status is true. Not a wiki page, not a chat thread, not a markdown file in a repository. If it is not on the board, it is not scheduled.

    A coding agent that starts a session with no memory needs one authoritative place to ask "what is in progress, what is blocked, and what did we decide yesterday." We give agents a short brief command that reads the board and the latest dated entry in our changelog, and every session begins there. We never rely on what an agent remembers from a previous conversation, because it does not remember.

    Three conventions keep the board useful rather than decorative.

    Planning categories. Every task carries exactly one category: Growth, Marketing, Product, Infrastructure, Reliability, Security, or Operations. The field is required when a task is created. Without a forced category, work drifts toward whatever is loudest, which is usually feature work, until a certificate expires or a disk fills. A required field makes the portfolio mix visible. When the board shows six Product tasks and no Reliability tasks in a month, that is a decision someone made, not an accident.

    Subject decides category, not the distribution theme. Engineering posts are tracked under a Marketing theme for public distribution, while each article’s category reflects its technical subject. A post on edge routing is Infrastructure. A post on consent and privacy is Security. A post on this operating model is Operations. Marketing is reserved for work whose subject is the channel itself. This keeps the category mix honest when one theme spawns many children.

    Duplicate check before creation. Agents are enthusiastic filers and will open the same task three times in three sessions. Our tooling runs a duplicate check first, and the override is used only after the result has been read.

    The result is a board that humans and agents both trust, which is the whole requirement. Narrative context, such as architecture decisions and the dated changelog, lives in a decision wiki linked from the board. Code, inventory, and scripts live in a private git repository. Each concern has one home, and the board links the others together.

    The AI inbox

    The second piece is the channel. We needed somewhere a human could drop a thought at any time, and somewhere an agent could surface a question or a result, without either side having to be online together.

    We implemented this as an inbox in two forms that share a purpose.

    The first is a dedicated card on the work board, the AI inbox, where humans leave instructions and agents leave results. Because it is a normal board object, it inherits everything the board already provides: history, mentions, linking, and search. Items that need real work get promoted into properly categorized tasks. Items that are just notes stay as comments.

    The second is a messaging channel connected to a small secretary process. It does three things that are easy to describe and surprisingly useful.

    1. A morning brief. Each morning it assembles a short digest of system status, has a language model word it plainly, and posts it. The brief is capped at a few lines. If it is longer than you can read while the coffee brews, it is not a brief.
    2. Capture on demand. Anything prefixed as a to-do or an idea is stored. On Saturday morning the secretary posts the open items, so thoughts raised on a Tuesday do not quietly die.
    3. Question answering. You can ask it about the state of things, and it answers from the same context an agent would have.

    The secretary has a formal, slightly dry persona. An assistant that sounds like an alarm gets muted. One that sounds like a calm colleague gets read.

    Two design choices are worth calling out.

    First, the secretary is a thin process. It does not host a model. For wording and question answering it calls out to a hosted agent service, and it holds only the credentials it needs, loaded at start through the service manager rather than stored in a repository. That keeps its footprint small enough to coexist with production workloads.

    Second, it only listens to an allowlist. It ignores every conversation except the one we designated. A messaging bot that accepts commands from anyone is a remote control for your infrastructure that happens to have a friendly face.

    Crucially, the inbox is a channel, not an authority. The secretary can capture a request and can draft a risky job. It can never perform one on the strength of a chat message alone.

    Routine versus risky

    Everything above would be an interesting productivity story if agents never touched production. They do. So the policy line matters more than the tooling.

    We split actions into two classes.

    Routine, no approval neededRisky, human approval required
    Read-only status and health probesScaling replicas
    Pulling and recreating a pinned imageChanging environment or secrets
    Restarting a container that is unhealthyInfrastructure-as-code applies
    One-step rollback to the previous known-good imageDatabase migrations, DNS changes, forced recreates
    Opening a dependency-bump pull requestMerging and deploying outside policy

    The routine column is reversible, bounded, and pinned to a known version. The risky column is where a mistake costs real data, real downtime, or real money. The distinction is not about how scary a command sounds. It is about whether you can cleanly undo it in one step.

    Some rules have no exception.

    • Deploys use pinned image versions, never a floating tag.
    • Secrets never appear in chat, commits, logs, or tickets.
    • Privileged host changes go through a single audited wrapper, never an open-ended root shell.
    • Logs are scrubbed of credential-shaped strings before anything leaves the host.
    • Repositories stay private unless someone explicitly decides otherwise.

    These are written into the agent instructions every session loads. More importantly, the executor enforces them, because it simply has no verb for the forbidden things.

    The approval flow

    Here is how a risky action actually moves through the system.

    An agent, or a person, decides something needs to happen on production. Rather than running it, they write a pending job: a small structured file that records an identifier, a plain-language summary, and the exact executor command to run. The command must be one of a fixed set of allowlisted verbs. Arbitrary shell is not representable in the file format.

    The pending job triggers a message in the approval channel with Approve and Reject buttons. A person reads the summary, decides, and taps one. Approval is a single decision on a single, fully specified job. It is not a blanket grant, and it expires in the sense that the job runs once and is done.

    Architecture diagram. Expand for a larger view with zoom.

    Several details in this diagram carry real weight.

    Intent comes before execution. The pending job is written before anything happens. A rejected proposal still leaves a record, and after an approval you can compare what was approved with what ran.

    The executor validates independently. The message layer is not trusted to enforce policy. When a job runs, the executor checks the requested verb against its own allowlist again. A forged or malformed job fails at the last gate, not the first.

    Failure has a defined next step. After a deploy, the executor waits for a health check. If the check fails, the rule is an immediate one-step rollback to the previous image, which sits in the routine class and needs no second approval. Fully automatic rollback is still deferred, so the operator or agent triggers it, but the path is one command and never a debate.

    The decision is attributable. Approval is a person's tap in a restricted channel, recorded alongside the job. "Who allowed this" has an answer that is not "the agent."

    Where workflow automation fits

    We run a workflow-automation tool on the control plane, on the laptop, where editor UX and spare memory make orchestration practical. It is the glue between systems that have APIs and no opinions about each other.

    Its role in approvals is deliberately narrow. There are two ways a decision can reach the executor, and the first is the primary one.

    The primary path is the secretary bridge on the server, which already owns the messaging connection and relays button taps straight to the executor. This is the path that works when the laptop is asleep, which is often.

    The second path is a laptop workflow that receives an approval webhook and calls the same executor with the same allowlisted command. We use it for automation experiments and for tests of the approval flow, where we want to drive the whole sequence without a human in a chat window. It does not replace the primary path, and it grants no additional capability. Same verbs, same allowlist, same one-shot job.

    There is a practical reason we do not run two competing listeners on the same messaging channel. The messaging platform allows only one consumer to pull updates for a given bot. If a laptop workflow polls the channel while the server bridge is also polling, they fight, and both lose. So one component owns the inbound channel, and the other path is webhook-driven rather than polling. Small constraints like this one decide architectures.

    The broader principle is that workflow automation is the place for glue that touches many systems, such as filing a board task when a job completes, posting a summary, or syncing a status to a changelog. It is not the place for the one narrow action that mutates production. That action belongs to the minimal executor, where the surface area is small enough to audit.

    What the server is allowed to be

    It helps to say plainly what we ask of the production host in this design.

    It runs customer workloads. It runs a small executor with a fixed vocabulary: status, digest, pull, deploy, restart, rollback, logs, inventory, checkpoints, and a few approved publishing actions. It runs a thin relay that passes human decisions to that executor. It keeps a log of deployments and results.

    It does not run a workflow engine, a code-writing agent, an LLM, or a planning tool. It does not hold the credentials for the board or the documentation space. Those live with the people and tools on the control plane, in locations with restricted permissions and out of any repository.

    This sounds restrictive, and it is, on purpose. The server can be rebuilt from a private repository of recipes and a pinned inventory of what should be running. The valuable, hard-to-replace things, the board, the decisions, the history, live elsewhere. If the host is lost, we lose uptime for a while, not our company memory.

    Agent sessions that start cold

    Agent-assisted work has a failure mode that humans mostly avoid: the stateless start. Every session begins with no memory. If instructions live in someone's head or in a chat history, they are gone.

    Our answer is a short, strict startup ritual written into the instructions agents load.

    1. Read the board summary and the newest changelog entry.
    2. Pick the next unblocked item from the board, rather than inventing a side quest.
    3. Do the work, and update the board and changelog in the same change set as the code.
    4. If something is worth a human's attention, send a short note through the secretary. Skip noise. Milestones, risks, and the occasional "everything is fine after a scary change" are enough.
    5. Treat any local plan file as stale the moment the board disagrees with it.

    The last rule is the one that earns its place. Local plans drift. A board that is the single live source of truth stops that drift by giving everyone, human or agent, one thing to correct.

    We also keep a learnings file that agents append to when a mistake repeats. It stores paths and tool names, never secrets, so a fix made in session three is not forgotten by session twelve.

    Trade-offs we accepted

    No operating model is free. Here is what this one costs us.

    Approval latency. A risky action waits for a human. For a deploy gone wrong at 3 a.m., that is a real delay. We accept it because the actions behind the gate are the ones where speed without judgment hurts most, and because the routine class, which includes one-step rollback, needs no approval at all.

    A single approver is a single point of failure. The person who can approve is sometimes asleep, traveling, or offline. We have not solved this with clever automation. The honest answer is that low-risk work was moved into the routine class so fewer things need a human, and the rest waits.

    Laptop dependence for planning. If the laptop is unavailable, agent-driven planning pauses. Production keeps serving and the board is hosted, so any machine can resume.

    More moving parts than a single box. Two planes mean a seam to maintain. We think a narrow, boring seam beats one tangled system, but it still needs care.

    What we would tell another lean team

    If you are thinking about something similar, the principles transfer even if the tools do not.

    • Separate where decisions are made from where actions run. Put the seam where you can enforce policy.
    • Make the executor dumb. A fixed vocabulary is easier to audit than an intelligent runtime. Intelligence belongs on the control plane.
    • Write intent before you act. A durable job record is worth more than a log written afterward.
    • Gate by reversibility, not by drama. If you can undo it in one step, let it run. If you cannot, ask a person.
    • Give agents one source of truth to read. Do not trust their memory, and do not trust yours.
    • Keep the channel and the authority apart. A chat window is a place to talk. It should not be the place where production changes happen without a structured, reviewable decision.
    • Keep secrets out of every shared surface. Boards, chats, logs, commits, and articles like this one. Treat a credential in any of those as already leaked.

    Where this goes next

    We have deliberately left some things unfinished. Rollback is a single routine step today, and making it fully automatic is deferred until we trust the signals behind it. Infrastructure-as-code applies remain behind approval. We are expanding the metrics the morning brief draws on, and we are working on a lightweight experiment brief so product bets get the same visible, categorized treatment as operational work.

    The shape of the system should stay stable even as the contents change. A hosted board that holds the truth, an inbox that connects people and agents, a laptop that does the thinking, and a production host that does exactly what a human has approved. At this scale, that is enough operating system to run on, and it is simple enough to explain on one page.