How we run Clock

This is our handbook. It’s written for the people who work here, and it’s public on purpose.

If you’re a customer, you’ll see what kind of company you’re buying from.
If you work at Clock, you’ll know what to do when the path isn’t obvious.

This isn’t “company values” wallpaper.
It’s a set of defaults. A shared spine. Something to lean on.

Table of contents

The point

Stability Is the Strategy

We build for Tuesday, not for demo day.

Tuesday is the day the lobby is full, someone calls in sick, a group arrives early, and the phone won’t stop ringing. Hotels don’t get to “pause” because software feels experimental.

So we made a choice at Clock:
We optimize for not being noticed.
In hotel software, “quiet” is success.

Stability is change you can trust:

  • Same action produce the same outcome.
  • Updates feel familiar, not disruptive.
  • When something breaks, recovery is fast and obvious.

We do stable work by keeping the blast radius small: steady releases, careful defaults, and no “big reveal” rewrites.

If a change makes the system shakier, it’s not progress. It’s debt wearing a feature costume.

Independent Buys Us Honesty

Independence is not a badge. It’s a tool.

It lets us tell the truth.
To customers. To each other. To ourselves.

Because when you don’t have investors to impress, you don’t need a story.
You just need a business.

Here’s what independence protects:

  • Decisions. We don’t trade product judgment for funding.
  • Priorities. We can choose what’s right over what’s loud.
  • Standards. We don’t cut corners to hit a target we didn’t pick.
  • Customers. We don’t need lock-ins, tricks, or pricing games.

Independence also makes some answers easier to give: “No.” “Not yet.” “That doesn’t belong.” “Here’s the trade-off.”

Honesty doesn’t always win the deal.
But it keeps the product clean and the relationship real.

We Don’t Chase Growth. We Earn Trust

Growth is a result, not a requirement.
The requirement is trust.

Trust is what makes a hotel stick with you after the first problem, recommend you after the tenth improvement, and forgive you when something goes wrong, because you handled it straight.

We earn trust the slow way:

By being predictable.
Same product, same behavior, fewer surprises.

By being careful with promises.
We’d rather under-promise than over-explain later.

By fixing the cause, not the optics.
We don’t optimize for screenshots. We optimize for Tuesdays.

If a decision makes us look bigger but act less trustworthy, it’s the wrong decision. We’re not building a growth machine. We’re building a company customers can rely on.

Small Is a Feature

“When are you going to get bigger?”

That question assumes “bigger” is the finish line.

For us, small isn’t a phase. It’s an advantage. It’s how we keep communication short, ownership clear, and quality high.

Small means decisions happen close to the work.
No telephone game. No layers of interpretation.

Small means problems don’t get abstracted away.
They don’t become “someone’s process.” They get solved.

Small means we can stay opinionated.
We can keep the product coherent instead of trying to please everyone at once.

We’re not trying to win enterprise trophies.
We’re trying to build software that holds up in real operations.

Decision-making

One Owner, One Outcome

If you’ve ever left a discussion thinking, “So… who’s actually doing this?” That’s the smell of shared ownership.

Shared ownership feels polite. It also kills momentum.
When everyone owns it, nobody drives it.

At Clock, every meaningful piece of work has one owner.

  • They define the next step.
  • They make the call when the team is split.
  • They keep it moving when it gets boring.

Ownership doesn’t mean doing everything alone. It means being responsible even when others contribute.

Write the Decision

Our memories are confident liars.
Writing is how we stop re-litigating the same decisions.

If something matters, it gets written down. Not as a novel. As a compact record.

The format is simple:

Problem:
What we know:
Options:
Trade-offs:
Decision:
Next step + owner:

Writing does three things at once: it clarifies thinking, it invites better feedback, and it creates a reference that outlasts the meeting.

Start With “No” (Then Make a Case for “Yes”)

Every “yes” adds something we have to carry forever: design, maintenance, edge cases, documentation, support, training, regret.

That’s why the first answer to most new ideas is: not now.

“Not now” isn’t dismissal. It’s a filter. If it’s real pain, it will come back. If it’s a nice-to-have, it usually disappears on its own.

When a “yes” is earned, it usually has these traits:

  • It removes work instead of adding steps.
  • It helps many hotels, not one special case.
  • It fits the product’s shape. It doesn’t bend the product into a pretzel.

The product stays useful because we say no. The company stays sane because we say no.

Solve the Real Problem, Not the Suggested Solution

People often ask for a feature. What they’re really asking for is relief.

Our job is to find the pain hiding behind the request. The request is rarely the root.

We pull on three threads:

  1. What happened? Describe the moment, not the idea.
  2. What are you trying to avoid? Time loss, errors, missed revenue, guest frustration.
  3. What would “fixed” look like? A behavior change, not a screen.

Sometimes the right solution is smaller than the request. Sometimes it’s different. Sometimes it’s saying, “This is an edge case, so let’s handle it with a human process.”

We don’t worship automation. We worship outcomes.

If It’s Hard to Explain, It’s Not Ready

Complexity loves long explanations. Simple work doesn’t need a tour guide.

We use a blunt test:

If we can’t explain what’s changing, who it helps, and what it replaces in one short message, we’re still designing.

“Hard to explain” usually means one of these:

  • Too many options.
  • Too many exceptions.
  • Too many new concepts introduced at once.
  • No clear trade-off was chosen.

The fix is rarely “better messaging.”
The fix is usually less.

Strong Opinions, Loosely Held

We don’t pretend every idea is equal. We argue for what we believe is right.

But we also don’t treat our opinions as identity. Reality gets the final vote.

  • Explore: Debate hard. Ask dumb questions. Find the risk.
  • Decide: Make the call. Document it. Move on.
  • Commit: Execute like it was your idea. Then measure what happened.

The only unacceptable move is passive resistance: agreeing in public, undermining in practice.

Time, focus, and calm

Calm Beats Chaos

We don’t run Clock like a newsroom.
We run it like infrastructure.

Chaos feels productive. It’s also expensive. It creates rushed decisions, shallow fixes, and burnout disguised as dedication.

We choose calm in practical ways:

  • We plan in chunks, not in adrenaline.
  • We prefer steady progress over heroic sprints.
  • We reduce work-in-progress before adding more.
  • We don’t reward “always on.” We reward “gets it done.”

Calm is not laziness.
Calm is how you build things that last.

No Fake Urgency

“ASAP” is not a plan. It’s a mood.

Real urgency exists. We handle it. But we don’t manufacture it to feel important.

We label work plainly:

  • Now: There is real damage if we wait.
  • Next: Important, but it can survive scheduling.
  • Later: Good idea, not a current priority.

If something is “Now,” we say what breaks, who’s impacted, and what the next checkpoint is. Otherwise, it’s just noise with a deadline costume.

Protect Deep Work

Most meaningful work requires uninterrupted thinking. The cost of interruption isn’t the minute you lose. It’s the half hour you spend rebuilding the thread.

So we design our days for depth:

  • We default to asynchronous communication.
  • We batch responses instead of ping-ponging all day.
  • We don’t treat “instant reply” as a virtue.
  • We respect “do not disturb” as a normal state, not a special request.

Deep work is how we earn simplicity. Without it, everything becomes a patch.

Meetings Are a Tax

Meetings consume the one resource nobody can refill: attention. That doesn’t mean meetings are evil. It means they need a receipt.

A meeting earns its spot when:

  • there’s a written summary beforehand,
  • the decision required is clear,
  • the right people are present (not the “just in case” people),
  • and the output is documented afterward.

No agenda, no prep, no decision needed? That’s not a meeting. That’s social time. Social time is fine. Just don’t hide it as work.

Fewer Projects, Finished Projects

Starting feels good. Finishing is useful.

Too many simultaneous projects create a special kind of slow: everyone is “busy” and nothing lands.

We prefer:

  • a small number of priorities,
  • clear owners,
  • and work that actually ships.

If you want to speed up Clock, don’t ask people to do more. Ask what we can stop doing so the important thing can complete.

Communication

Default to Writing

Writing is how we think together without dragging everyone into the same hour.

It makes ideas inspectable. It reduces misunderstandings. It turns “I thought we agreed” into “here’s what we agreed.”

Good internal writing is:

  • Skimmable. Headings and short paragraphs.
  • Honest. Assumptions included.
  • Actionable. Clear next step and owner.

If you want fewer meetings, write better notes.

Say the Quiet Part Out Loud

Most problems don’t come from bad intent. They come from unstated assumptions.

So we say the uncomfortable parts early: the risk, the downside, the trade-off, the constraint.

Examples of “quiet parts” worth naming:

  • “This will increase support load.”
  • “This only works for one segment of customers.”
  • “This creates a new maintenance surface.”
  • “This is reversible / not reversible.”
  • “We’re guessing here.”

Silence doesn’t keep things smooth. It just delays the bump until it’s more expensive.

Disagree Without Drama

Disagreement is a normal part of building a coherent product. Drama is optional.

Our rules are boring on purpose:

  • Attack the problem, not the person.
  • Bring evidence, not volume.
  • Prefer “What would change your mind?” over “You’re wrong.”
  • Don’t recruit an audience.
  • Don’t keep score.

We’re not trying to win debates. We’re trying to make good calls with limited time and imperfect information.

Make It Easy to Pick Up

Work shouldn’t be a treasure hunt. It should be legible.

The best test is simple: if you disappeared for a week, could someone continue without guessing?

We make work pick-up-able by default:

  • clear titles,
  • short status notes (“what’s done / what’s next / what’s blocked”),
  • decisions captured in writing,
  • links to the important context in one place.

If it’s hard to pick up, it’s hard to ship.

Standards we don’t negotiate

Reliability Over Novelty

New isn’t automatically better. Sometimes new is just new.

We make software for daily operations. Daily operations punish surprises.

So we prefer improvements that:

  • reduce manual work,
  • reduce errors,
  • reduce support friction,
  • and make the product easier to trust.

If something is “cool” but not “useful,” it doesn’t belong. We’re not building a novelty shop.

Quality Is Everyone’s Job

Quality isn’t a phase at the end. It’s a habit throughout.

“Done” at Clock means:

  • it works,
  • it’s understandable,
  • it doesn’t break what’s already working,
  • support can explain it without improvising,
  • and we can maintain it without heroics.

If quality is “someone else’s responsibility,” quality becomes nobody’s responsibility. We don’t do that.

Small Changes That Stick

We prefer tune-ups over renovations.

Big rewrites are tempting because they feel like a clean slate. They also create a long stretch where nothing improves for customers. And then the new thing arrives with new bugs and new surprises.

Instead, we improve the real product, in the real world, in increments that can be tested, understood, supported, and rolled out safely.

Small changes compound. Big rewrites restart the clock.

Do the Simple Thing

“Simple” is not the easiest option. It’s the option that stays understandable a year from now.

We choose simplicity by doing less of this:

  • more settings, more modes, more exceptions,
  • features that exist “just in case.”

And more of this:

  • clear defaults,
  • fewer moving parts,
  • real words,
  • workflows that feel obvious.

Simplicity doesn’t happen once. It’s maintenance.

Customers are the reality check

Customer Reality Beats Internal Opinion

We can argue beautifully and still be wrong. Hotels don’t care how good our argument was. They care if the workflow works.

So we treat real usage as the judge. What customers do in the system beats what we think they should do.

We trust:

  • observed patterns over loud requests,
  • recurring pain over one-off preference,
  • busy-day reality over ideal-day theory.

We don’t build for “power users.” We build for operators who have ten things happening at once.

Support Is Where Truth Lives

Support is not a cost center. It’s where reality shows up with receipts.

Support sees confusion first. Support sees friction first. Support sees the gap between what we intended and what customers experience.

So we treat support like product work:

  • Patterns matter more than individual tickets.
  • Repeated questions mean the design failed, not the customer.
  • We fix the system, not the symptoms.

A company that ignores support ends up with a product that can’t be defended. We want a product we can defend.

Clarity Over Speed

A fast answer that confuses creates a second question. And a third. That’s not speed. That’s a loop.

We’d rather take an extra moment and give the answer that closes the issue: clear steps, real words, and the “why” when it matters.

Clarity scales:

  • It reduces follow-up.
  • It reduces mistakes.
  • It reduces anxiety.
  • It makes customers feel in control.

The goal isn’t to reply quickly. The goal is to resolve.

We Don’t Sell Confusion

Confusion is expensive. It wastes time in onboarding, in support, in billing, in trust.

So we don’t build a business that depends on customers being confused.

  • No hidden traps.
  • No “gotcha” pricing.
  • No ritualized mystery (“book a call to see the thing”).
  • No pretending complexity is sophistication.

If we can’t explain it plainly, we shouldn’t be selling it.

How we grow (without losing ourselves)

Profit Pays for Patience

Profit isn’t a flex. It’s stability for the company and for the product.

Profit buys things we value:

  • time to fix things properly,
  • room to say “no” to bad deals,
  • freedom from desperate decisions,
  • and the ability to stay calm.

We don’t borrow time from the future. We pay our way. That’s how we stay in control of our priorities.

We Invest in the Product, Not the Theater

There’s a kind of work that looks impressive and changes nothing. We avoid it.

We’re not interested in:

  • launch noise without lasting improvement,
  • big announcements for small changes,
  • roadmaps as marketing,
  • vanity metrics that don’t help hotels.

We are interested in:

  • boring reliability work,
  • steady improvements that stick,
  • documentation and support that reduce friction,
  • systems that run smoother year after year.

The product is the story. Everything else is decoration.

Trends are loud. Hotel operations are louder.

We don’t adopt something because it’s popular. We adopt it when it helps the customer, fits the product, and won’t compromise stability.

Our bar is practical:

  • Does it reduce work or reduce risk?
  • Will it still make sense in three years?
  • Can we support it without turning support into detectives?
  • Does it keep the product coherent?

We’re not anti-new. We’re anti-noisy.