Infrastructure, orchestrated.

Case Study

Built in two days.
No developer on the team.

This website — every template, every animation, every line of CSS — was built by an agent team directed by Ian Hammond, OTOT co-founder. Ian is not a developer. Here's exactly what was built, how the team worked, and what it would have cost to do it the traditional way.

What two days of agentic work produced.

This wasn't a proof of concept. It was a production deployment — a complete HubSpot CMS theme, built to spec, live in the Design Manager, and fully matched to the original brand designs.

No briefing documents. No development tickets. No waiting. Ian gave directional feedback; the agent applied it and deployed immediately.

2

Days from start to live deployment

2,163

Lines of code written (CSS, JS, HubL)

8

Custom HubSpot modules built

0

Developers on the team

A complete HubSpot CMS theme. From scratch.

Not a marketplace template. Not a modified default. A fully custom theme built to HubSpot's Design Manager architecture — with a complete brand system, custom JavaScript, and six production page templates that match the original designs exactly.

  • 876-line CSS design system — every colour, component, animation, and responsive breakpoint
  • Custom JavaScript scroll engine — parallax, section reveals, staggered animations — no libraries
  • 6 production page templates: Home, Orchestration, Exacto, Advisory, About, Contact
  • 8 custom HubSpot modules with field schemas and HubL templates
  • Navigation macros, footer macros, theme config and field definitions
  • Mobile-responsive throughout — burger menu, stacked grids, touch-friendly interactions
  • WCAG-compliant colour contrast across every component
OTOT/
├── css/ main.css (876 lines)
├── js/ scroll-fx.js (80 lines)
├── templates/
│ ├── home.html
│ ├── orchestration.html
│ ├── exacto.html
│ ├── advisory.html
│ ├── about.html
│ ├── contact.html
│ └── page.html
├── modules/ 8 custom modules
│ ├── page-hero.module
│ ├── cta-section.module
│ ├── proof-callout.module
│ ├── rich-text-section.module
│ ├── pillar-cards.module
│ ├── step-list.module
│ ├── three-col-cards.module
│ └── two-col-content.module
├── macros/ navigation, footer
├── images/ brand logo variants
├── fields.json
└── theme.json

876 lines of brand CSS. Every component accounted for.

The stylesheet isn't a collection of overrides on a base framework. It's a ground-up design system — CSS custom properties for the full OTOT brand palette, a typography scale, a grid system, and a complete component library covering every element on every page.

It also includes a full scroll animation system — built in vanilla JavaScript using the Intersection Observer API and requestAnimationFrame. No GSAP. No jQuery. No external dependencies.

  • Lime progress bar — fixed at top of every page, glows on scroll
  • Hero parallax — four layered elements (orb, rings, dot grid) moving at different rates at 60fps
  • Section reveals — each section slides up into view as it enters the viewport
  • Card stagger — pillar cards, tier cards, and steps animate in sequence on reveal
  • Hero entrance — label, headline, sub, and CTAs each lift in on load with staggered delays
  • Step number bounce — spring-curve keyframe animation on each numbered step
  • Lime underline draw-in — section headings get a 56px lime line that draws in on reveal

Six pages. Each one built to match the original design.

Home

Tagline strip → Hero ("One system. Not seven.") → Problem in two columns with cost callout → Two pillar cards on khaki → Proof callout → CTA

Orchestration

Navy hero → Problem (khaki) → What is / What isn't in two columns with navy contrast card → Four-step process with "Who it's for" sidebar → 90-day Pilot spec table → CTA

Exacto

Khaki hero → HubSpot ceiling problem with navy stack diagram showing disconnected tools → What it is (khaki) → Four audience types → Four-step build process across two columns → Outcomes with proof callout → CTA

Advisory

Khaki hero → Six-figure decision problem → What is / What isn't with navy contrast card → Who it's for on khaki → Three tier cards (Foundational / Strategic / Principal) → CTA → HubSpot callout

About

Khaki hero → Origin story with three stat cards (2 / 0 / ANZ) → Founder cards for Ian and Neil → Conekter technology partner section → Four differentiator items → "The name" section → CTA

Contact

Full-height khaki layout → Two-column contact grid → Ian and Neil with email and LinkedIn links → Booking widget placeholder ready for Calendly or Cal.com

One agent. Directed by a non-developer. In two days.

The work was directed through the claude-code agent — running in the Claude Code environment with direct filesystem access, bash execution, and the HubSpot CLI already configured. Ian gave directional feedback. The agent made technical decisions and deployed each iteration immediately.

Four capabilities made this possible at this pace.

Multi-file coordination

The agent held 876 lines of CSS, five original HTML reference files, eight page templates, and multiple module schemas simultaneously — making consistent, coordinated changes across all of them.

Platform-specific knowledge

HubSpot's CMS has non-obvious constraints. The agent navigated them — correct HubL syntax, Design Manager path conventions, module schema structure, CLI upload behaviour. Ian knew none of this and didn't need to.

Iterative refinement without re-briefing

Ian said things like "the spacing doesn't look as good as the original" and "can we make the animations more pronounced." The agent translated each note into specific code decisions and applied them immediately. No ticket. No brief. No developer to chase.

Immediate deployment

Every iteration deployed directly to the live HubSpot account using the CLI — not uploaded manually through the Design Manager UI. Feedback-to-live was measured in minutes, not days.

What this would have cost the traditional way.

To scope this project through a freelancer or agency, you'd need at minimum four specialists. Here's how the numbers stack up.

Role Scope Hours Rate Cost (AUD)
HubSpot developer Theme architecture, module builds, HubL templating, CLI setup 40–60 hrs $150/hr $6,000–$9,000
Front-end developer CSS design system, JS scroll effects, responsive layout, accessibility 24–40 hrs $140/hr $3,360–$5,600
Designer Design system definition, component specs, spacing and typography 16–24 hrs $150/hr $2,400–$3,600
Copywriter Migrating and adapting copy from reference designs into templates 8–12 hrs $150/hr $1,200–$1,800
Project coordination Briefing, review cycles, revisions, stakeholder comms 8–12 hrs $120/hr $960–$1,440
Total 96–148 hrs $13,920–$21,440

Traditional route

6–8 weeks

Estimated timeline including briefing, development, review rounds, and revisions


3–5 people

To manage, brief, review, and chase across the engagement


15–20 hrs

Of Ian's own time — briefings, reviews, approvals, and follow-ups

With the agent team

2 days

Start to live deployment. No waiting for availability. No sprint planning.


0 people

Managed externally. Zero coordination overhead. Zero handoff points.


3–4 hrs

Of Ian's time. Directional. No briefing documents. No approval rounds.

Total external spend on this build: effectively $0 beyond an existing subscription.

~$30/mo

The agent team didn't replace Ian's thinking. It removed the friction between what he needed and what got built.

Ian directed it. He didn't specify it. He said what wasn't right; the agent read the reference, identified the gap, and rebuilt to match. That's interpretation — not instruction-following.

The output is production-quality. Not a prototype. Not a proof of concept. A fully deployed, WCAG-accessible HubSpot theme running live right now.

The complexity was real. HubSpot's CMS has platform-specific constraints that take an experienced developer time to learn and navigate. The agent knew them. Ian didn't need to.

And the iteration cycle was frictionless. Every directional note applied and deployed the same session. No ticket. No waiting. No "I'll check with the developer."

This is what Orchestration looks like in practice.

The agents that run inside your operational tools work the same way. You direct. The agent does. The friction disappears.

See how Orchestration works

This website was built by our agent team. Two days. No developer.

You're reading the case study ↑