Какво правим
Софтуер, от А до Я
Правим уеб платформи, AI функции и десктоп приложения. Повечето проекти попадат основно в едно от трите и вземат по нещо от другите.
// 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
Софтуер по поръчка и уеб платформи
Уеб приложения по поръчка, вътрешни инструменти и пълноценни SaaS платформи. Започваме от модела на данните, защото всичко над него наследява грешките му.
- SaaS, който продавате на много фирми
- Вътрешни инструменти вместо Excel
- Свързване на съществуващите ви системи
- Вход, права за достъп и абонаменти
AI интеграции и агенти
Добавяме AI към съществуващи продукти и създаваме самостоятелни агенти. Когато данните не могат да напускат системите ви, моделът работи на устройството.
- LLM функции и автономни агенти
- Локален и edge инференс
- Автоматизация на процеси и документи
- Поверителност по подразбиране и данни в ЕС
Десктоп и крос-платформени приложения
Приложения, които работят на самия компютър и имат достъп до файлове и хардуер, недостъпни за браузър. Продължават да работят и когато връзката прекъсне.
- Tauri и крос-платформен десктоп
- Работа офлайн и фонова синхронизация
- Екрани с данни в реално време
- Системен трей, известия и автообновяване
Разкажете ни за проекта си
Няколко изречения са достатъчни за начало. Отговаряме лично на всяка заявка, обикновено до един ден.
одобрявате офертата · всичко, което направим, е ваше
Проектите започват в клиентския ни портал. Регистрирате се и изпращате заявка за проект. Или просто пишете на hello@vezoft.com.