// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros/core/session.ts — one session per user, classified as it happens
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core";
import { classify } from "./on-device/model"; // bundled with the app
import { payroll } from "../billing/payroll";
export async function track(user: User): Promise<Session> {
const session = await Timer.start(user.id, { mode: "productive" });
session.on("activity", (event: ActivityEvent) => {
const kind = classify(event); // productive · idle · break
session.record(kind, event.duration); // rolled up per project
});
session.on("idle", () => session.pause());
return session.commit({ at: trustedNow(), tz: user.timezone });
}
// cost from payroll, revenue from the client rate → profit per project
export function settle(projects: Project[]): Money[] {
const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR" });
}
// the studio's own week runs through this same path
const week = sum(sessions, "productive"); // productive time only
const team = await Org.active(); // everyone in one workspace
export const live = stream(team, week, { realtime: true });
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
// timeros — sessions are classified on the device, then rolled up into projects, payroll and invoices
import { Timer, Session, Project, Invoice, Client } from "@vezoft/core"; import { classify } from "./on-device/model";
export async function track(user: User): Promise<Session> { const session = await Timer.start(user.id, { mode: "auto" });
session.on("activity", (event) => { const kind = classify(event); session.record(kind, event.duration); }); // classification stays on the machine
session.on("idle", () => session.pause()); return session.commit({ at: trustedNow(), tz: user.timezone, by: user.id });
}
// roll the week up into projects: cost comes from payroll, revenue from the client rate, profit falls out of the two
export function settle(projects: Project[]): Money[] { const profit = projects.map((p) => p.hours * p.rate - p.cost);
return payroll.run(profit, { region: "EU", currency: "EUR", period: "month" }); } // run once a month
export async function invoice(client: Client) { const open = await Invoice.pending(client.id); return sum(open, "total"); }
const week = sum(sessions, "productive"); const team = await Org.active(); export const live = stream(team, week, { realtime: true });
// the studio runs entirely on this — one workspace for time, projects, clients, shifts, payroll and the client portal
How we work
A clear path, an agreed price
From the first conversation to working software, with a scope and a price you agree to before we start.
01Understand
02Design
03Build
04Run
What you see
You watch the work as it happens
Every project lives in our client portal. Open it when you like and see where the work stands, what it has cost so far, and what is waiting for you — without asking for a weekly report.
Click anything in it. Every name and figure is made up.
What is waiting for youActive projects, open issues and invoices still to pay — on one screen, without having to ask.
Open the client portal
Each client sees only their own company. Access comes with the project.
The process, up close
What each step means
01
Understand
We start with the problem and the constraints around it. Discovery is short, and it ends in a written scope you can hold us to.
02
Design
You get clickable screens before we write production code, and the data model underneath them. Changing a screen at this stage takes an afternoon.
03
Build
Iterations are short and each one ends with software that runs. Nothing sits half-finished for a month while we work on something else.
04
Run
After launch we watch how it behaves in real use and fix what shows up. Whether we stay on for that or hand it to your own team is your call.
BriefDesignBuildAI agentAPITestDeployAutomateReviewShipRunClient portalDataSync
Ways to work together
A project, a partnership, or a second opinion
One team covers all three. What differs is how long we stay and how much is fixed up front.
Project build
You have a clear outcome in mind.
A defined product, platform or feature. We scope it first, then quote once and build to that scope. Fits when the outcome is clear enough to put a price on.
Ongoing partnership
A single build will not cover it.
We act as your product engineering team and work in short cycles on whatever the product needs next. The same senior people stay with you as it grows.
Advisory & review
You need senior judgement, fast.
Architecture reviews, technical due diligence, a second opinion before you commit. Days, not months.
Pricing
Most projects are fixed-scope: a short paid discovery, then a quote you approve before we build. Longer partnerships run on a monthly fee, agreed before the first month starts.
When the scope changes mid-build, and on a long project it usually does, we price the change on its own and you decide before we start it. Every line on your invoice is one you agreed to beforehand.
Discovery first
The quote comes after a paid discovery, so the price rests on work we have already done.
Working software, early
You get something you can open and use long before the project ends, and what you say about it decides what we build next.
Direct access
You write in the project thread in our client portal, and the people building it answer you there.
You own it all
Code, designs, accounts and infrastructure are yours throughout the project. Ask for a handover at any point and you get all of it, documented.
If this fits, start here
A few sentences are enough to start. We answer every request personally, usually within a day.
you approve the quote · you own everything we make
Projects start in our client portal. You register there, then send a project request. Or just email hello@vezoft.com.