Marketing Operations for a Team of One: The Operating System I Actually Run

Marketing Operations Without the Department

Search for marketing operations and the results describe a world you do not live in. Definitions written for companies that already have a MOps manager. Career ladders. Hiring guides. A jobs board. Even the Reddit thread near the top is people asking what the job actually is. Every result assumes a department, a budget, and a martech stack with an owner.

I run marketing operations as a department of one. By day I am Head of Marketing for SSI Schäfer in Switzerland. Around that I run consulting engagements and my own projects, and in that second world nobody owns the pipeline except me. That is exactly why I stopped shopping for a stack and started building an operating system.

Here is the difference. A stack is a list of tools that each hold a piece of your work. An operating system is the layer underneath the tools: where tasks live with a state, where decisions land with a log, where automations run through gates, and where a human still signs off on anything that ships. The corporate guides answer which tool to buy. This article answers which system to run.

The receipts are all mine. A task vault holding 623 open checkboxes across 26 task files. A dashboard I built myself, covered by 34 tests that caught 3 real bugs before production. A funnel that notifies me on every lead. A database that checks every keyword before I write and registers every article after it ships. Total software cost: close to zero. Total discipline cost: that is the honest part, and I will pay it out in full below.

Key Takeaways

• Marketing operations at solo scale is state, not stack. A task with a status, a decision with a log, a pipeline with a gate. Get those three right and the specific tools barely matter.
• Your backlog needs an address. My 623 open checkboxes across 26 task files are findable in seconds because every task lives in a numbered structure with rules, not in my head.
• The dashboard is a build, not a purchase. The Nexus runs on plain Python with zero dependencies: five views, seven alert rules with snooze, live updates, atomic writes.
• Automate the volume, keep the verification human. Machines draft, route and notify. A mandatory human queue decides what ships. No exceptions, however tempting.
• Ops applies to content, not just campaigns. A small PostgreSQL database prevents keyword cannibalization across 2 sites and 5 languages, checking every keyword before writing and logging every article after.
• Failures happen at the joints. Webhook to queue, draft to publish, one language to the next. Design the joints first, and the system survives your absence.

What Marketing Operations Means When You Are the Department

Strip away the corporate layer and marketing operations is four jobs. Capture: every commitment, lead and idea gets written somewhere with a state, the moment it appears. Routing: work moves between states, inbox to doing to waiting, without living in email. Verification: nothing customer-facing ships without a human gate. Measurement: the system records what happened, so Friday’s decision does not evaporate by March.

A department spreads those jobs across people and titles. A one person marketing team compresses them into files, scripts and rules that run whether or not I remember them. That compression is the whole game: not a smaller version of enterprise MOps, but an operating system for one operator.

The lens I use is simple: anything I have to remember is a defect, whether it is a lead follow-up, the glossary for a translation, or last month’s keywords. The system exists to catch them, and I measure it by how few things I still hold in my head.

I wrote about the memory side, the second brain my agents read, separately. This is the work side: not only a memory the AI can query, but a production line the work flows through. Memory stores decisions. Operations move work. You need both, and in my system they share the same foundation.

Every Task Lives With a State

That foundation is an Obsidian vault with numbered folders and a rules file the AI agent reads by itself. 00 Inbox for unsorted captures. 10 Daily for the day’s log. 20 Tasks for the work, every open loop as a checkbox with a status and, when it exists, a date. The numbering is routing: a task question starts in 20, a knowledge question starts in the wiki, and nothing ever starts in the archive.

The number that matters: 623 open checkboxes across 26 task files, in a system I query every day. That is not a backlog to be ashamed of. It is a portfolio with addresses. Ask what is still owed on any project and the answer comes back in seconds, quoted from the actual files. Nothing waits in my head, which is the only place a solo operator cannot afford to keep work.

Each area also keeps a recency file answering one question: where did I leave this. Status lines, the last things touched, who is waiting on what, anything older than thirty days compressed away. Open a conversation about a project and the context arrives before the question finishes.

Because agents touch this vault too, the system logs its own performance. Every serious query gets a line with an outcome: ok for an efficient answer, gap for missing information, consolidate when three files had to be read for one answer, noise for files that did not help. Operations without measurement is a filing habit. The log is what makes it a system.

The Nexus: The Dashboard I Built Instead of Buying One

Checkboxes in files are the source of truth, but a one-person team also needs a control room, so I built one. The Nexus is a task dashboard in plain Python with zero dependencies: nothing to break when the machine changes. Five views over the same task files, seven alert rules with snooze, live updates streamed over SSE, and atomic writes so a crash can never corrupt the state.

The engineering story is short, because it should be. It shipped with 34 tests, and those tests caught 3 real bugs before anything reached production. When I migrated 529 tasks from the old system, the counts had to reconcile, and they did, because a migration without a count is just data loss with confidence. The method behind it, small slices and hard review, is how I build every internal tool.

What the alerts do is turn forgetting into a signal instead of a failure. A deadline approaching, a task waiting too long, an item that missed its promised date: each becomes a notification with a snooze, not a knot in my stomach on Sunday evening. Seven rules, each born from a specific way I once dropped something.

Pipelines With Gates: Automate the Volume, Keep the Verification Human

My subscription funnel runs end to end without me. A form submits, a webhook catches it, the lead lands with its source attached, and a notification reaches Mattermost within moments. The site rebuilds automatically every two minutes. Deploys announce themselves. Nothing in that chain waits for me to press refresh.

What that chain deliberately does not do is publish. Everything a customer could read passes a mandatory human review queue. The machine drafts, translates, schedules. The queue is where I read it, in every language it will ship in, before anything goes live. Machines handle the volume. A human owns the yes.

I compress the rule into one line: automate the volume, verify like a human. It survives every tempting exception, because the tempting cases are always the high-volume ones: the newsletter in its fifth language, the landing page late at night. Each is one skipped gate away from a public mistake, and public mistakes do not scale down for small teams. They are proportionally larger.

The full newsletter pipeline has its own article. The operations insight is narrower: notifications and gates are a pair. Every automation that acts must notify, and everything that ships must pass a gate. Automations without notifications fail silently; gates without automation get waved through once the volume backs up. You need both halves, and lead notifications plug straight into the same funnel discipline.

Ops for Content: A Database That Prevents Cannibalization

Most teams discover keyword cannibalization in an analytics report, months late. I publish across 2 sites and 5 languages, which multiplies the collision surface, so content needs operations too. Mine is a small SEO database: PostgreSQL plus an API, with two moments that matter.

Before writing, a keyword check: is this phrase already the primary keyword of another article, in this language, on either site. After publishing, an upsert: the article, its keyword, its language and its URL go into the registry. Every article I ship is registered, which means every future article is checked against the full inventory before a single word is written. Cannibalization stops being something I discover and becomes something the system refuses.

This is the part of marketing operations nobody writes guides about, because there is no vendor to buy it from. It is a habit plus a small database that costs almost nothing, and it changes what content production is: not a sequence of inspirations, but a logged pipeline with a gate in front of it. The same discipline as the review queue, applied to strategy instead of copy.

Time Tracking That Writes Itself

Every real action in my day, an email sent, an article shipped, a decision taken, a task captured, gets a timestamp line in the daily note, written while it happens rather than reconstructed on Sunday. The daily note becomes a natural time tracker: the pricing decision landed at 14:30, the client email went out at 15:10, and the gap between two stamps is how long the thing actually took.

There is no standup where the truth surfaces, so the timestamped log is my standup: where the hours went, which projects eat days, whether today’s work matched the plan, answered with data instead of memory. Quarterly reviews stop being vibes. The log also feeds everything else, because recency files and summaries derive from it instead of competing with it. One record, many views. That is operating system behavior, and it costs one habit.

What It Costs, Honestly

The money is the boring part, which is the point. The vault is plain files, the dashboard is standard-library Python, the database is one PostgreSQL instance, notifications ride Mattermost, webhooks come with tools I already use. Monthly cost of the whole stack: close to zero, and most components exactly zero.

The real cost is discipline, and it has three lines. Tasks must be written down, not remembered, every time, or the state rots. The review queue must actually be reviewed, or the gate becomes theater. The logs must be kept, or the system stops improving and starts fossilizing. None of that is hard for a week. All of it is hard for a year.

The trade is explicit. I pay attention at review time, and in exchange I get a memory that does not fade, deadlines that shout instead of whisper, and a workload I can query instead of dread. For a team of one, that is the best employment contract available. For the full inventory, my current marketing tech stack is documented here, and the operations layer is deliberately its cheapest part.

Where It Breaks: The Joints

Two and a half years in, the failure pattern is clear. Nothing fails in the middle of a tool. Everything fails at the joints, where one system hands work to another. The webhook that stops firing and nobody notices, because notifications were the part I skipped. The task marked done in one place and open in another, because two sources of truth drifted. The translation that ships with the wrong terminology, because the gate checked spelling but not meaning. The joint is where the defect enters, so the joints are where the design effort belongs: one source of truth per fact, a notification on every automated action, a human gate on everything that ships.

Maintenance is a cadence, not a crisis. Weekly, the recency files get rotated and stale items drop out. Monthly, the query log shows which answers needed three files, and those files get merged. The archive quietly absorbs the dead. Skip it for a quarter, and the operating system degrades into a filing cabinet with delusions.

Here is the verdict. Marketing operations for a team of one is not a smaller department, and it is not a stack. It is a discipline: state for the work, gates for the output, logs for the truth, notifications for the silence. Build it from files and small scripts, spend almost nothing, review everything that ships. The companies in those search results are hiring for this function. You can simply run it.

Frequently Asked Questions

What does marketing operations actually include?

At any size, four jobs: capturing work with a state, routing it between states, verifying what ships through a human gate, and measuring what happened. Departments buy a tool for each. A one-person team compresses them into files, scripts and habits, which is cheaper and harder to break.

Do I need a martech stack before I can run marketing operations?

No, and buying first usually makes things worse, because tools multiply states instead of unifying them. The stack is the last mile, not the foundation. Start from state: one place where every task, decision and deadline lives and can be found. Automate only where volume repeats, and gate everything that faces a customer.

How do I start marketing operations as a one-person team?

Start this week, with three moves. Give every task one home and one state. Put a mandatory review step in front of anything a customer can read. Log every real action with a timestamp. Those three are the skeleton of marketing operations, they cost nothing, and every automation you add later will attach to one of them.