RunwayOps
RunwayOps is an autonomous cashflow operating system for small businesses. It ingests messy financial data, forecasts cash risk, builds customer intelligence, decides who to contact, drafts tailored outreach, prepares execution, waits for human approval, records every action, and continuously learns from outcomes.
Inspiration
Small businesses do not usually run out of ideas. They run out of cash timing.
Globally, SMEs face an estimated $5.7 trillion finance gap. In the UK alone, late payments cost the economy around £11 billion every year, and reported figures suggest 38 businesses close every day because cash does not arrive when it should.
That is not an abstract finance problem. It is a founder staring at payroll, an unpaid invoice, a supplier obligation, and a bank balance that does not give them enough time.
Most tools do not solve this. Accounting software stores the past. Dashboards visualize the present. Spreadsheets let someone manually model the future. But when a founder asks, “What should I do right now to protect runway?”, the answer is usually still buried across invoices, emails, customer history, payment patterns, and human memory.
I built RunwayOps because cash management should not be passive business intelligence. It should be an intelligent operating loop.
What It Does
RunwayOps acts like an autonomous finance operator for small business cashflow.
A user can upload or refresh financial data, and the system begins building a live operating model of the business:
- It ingests financial evidence: invoices, obligations, customer records, payments, and source files are normalized into an Aurora-backed operational model.
- It creates customer profiles: who owes money, how much is outstanding, who the contact is, how they usually pay, and which channel works best.
- It forecasts cash risk: deterministic projections identify runway pressure, low points, payroll risk, and upcoming obligations.
- It decides what matters most: the agent ranks recovery actions by urgency, cash impact, timing, customer behavior, and likelihood of success.
- It creates an action plan: who to contact, why now, which invoice matters, what the expected cash impact is, and what the best next step should be.
- It tailors communication: RunwayOps generates context-aware email drafts and call scripts based on customer memory.
- It prepares execution: the system moves from recommendation to action-ready state.
- It waits for human approval: autonomy is bounded; outbound action is gated by approval.
- It executes through provider rails: approved workflows are designed to run through channels such as voice or email.
- It learns continuously: outcomes become memory that improves future recommendations.
The result is not a dashboard. It is a cashflow command loop: sense, forecast, decide, approve, execute, learn.
The AI Factor
RunwayOps is not a chatbot sitting beside a finance app. The AI is embedded inside the operating workflow.
The system behaves like a team of specialist finance agents:
- Forecast Agent recomputes runway, low points, obligations, and scenario risk.
- Memory Agent retrieves customer behavior, contact preferences, payment history, and learned facts.
- Collections Agent decides who to contact, what to say, which channel to use, and what action has the highest cash impact.
- Audit Agent records evidence, approvals, checkpoints, provider status, and memory updates.
The crucial design choice is that the AI does not invent financial numbers. Cash balances, invoices, obligations, forecast points, approvals, and provider records are grounded in Aurora PostgreSQL.
AI is used where it is most valuable: understanding messy customer context, explaining risk, ranking the next best action, drafting personalized outreach, preparing call scripts, extracting memory from outcomes, and turning backend workflow state into a readable business timeline.
That makes RunwayOps more than automation. It is a bounded autonomous agent: powerful enough to act like a finance operator, but constrained enough to be trusted with sensitive cash workflows.
Product Architecture
| Layer | What It Does | Why It Matters |
|---|---|---|
| Vercel + Next.js | Hosts the public product UI and API route runtime | Judges can open and use the product as a real deployed app |
| Premium cashflow cockpit | Overview, Forecasts, Actions, Customers, Agent Activity, Settings | Turns complex agent/backend state into an intuitive customer-facing product |
| Aurora PostgreSQL | Stores finance state, events, forecasts, actions, approvals, provider logs, memory, agent checkpoints, and audit records | Acts as the operational source of truth |
| Amazon RDS Data API | Lets Vercel serverless routes query Aurora without persistent database connections | Makes the architecture production-oriented |
| Amazon S3 | Stores source-file provenance for uploaded finance evidence | Makes ingestion auditable and replayable |
| LangGraph | Coordinates agent runs and durable checkpoints | Makes the workflow inspectable and resumable |
| Fireworks AI | Powers structured reasoning, action ranking, drafts, call scripts, and memory extraction | Makes the agent useful without corrupting deterministic finance math |
| LangSmith | Provides trace readiness for agent workflows | Makes agent behavior debuggable and evaluable |
| Twilio / Gmail provider layer | Supports approval-gated outbound execution | Turns recommendations into real-world action |
| Audit + memory loop | Records approvals, execution state, outcomes, and learned customer facts | Creates continuous improvement over time |
How I Built It
I built RunwayOps as a full-stack Vercel application with Aurora PostgreSQL as the core backend.
The frontend is a polished Next.js product cockpit built for a founder or finance operator. It is intentionally simple on the surface: current cash risk, forecast pressure, recommended action, approval queue, customer memory, and agent activity.
The backend is where the complexity lives. RunwayOps has API routes for product overview, actions, action detail, approvals, draft editing, customer profiles, scenario forecasting, agent activity, demo intake, uploads, voice readiness, TwiML, and provider webhooks.
Aurora PostgreSQL stores the complete operating model: companies, cash accounts, customers, contacts, invoices, obligations, payments, source files, event inbox rows, event ledger rows, forecast runs, forecast points, action plans, actions, approval records, communication drafts, provider executions, voice calls, transcripts, memory chunks, agent runs, agent checkpoints, trace metadata, and audit logs.
The Vercel runtime talks to Aurora through the Amazon RDS Data API, which lets the app use a serious relational backend from a serverless deployment model.
On top of that, LangGraph coordinates the agent workflow, Fireworks generates structured reasoning and outreach, and LangSmith provides observability hooks for tracing and evaluation.
What Makes It Different
Most finance tools answer: “What happened?”
Some forecasting tools answer: “What might happen?”
RunwayOps answers: “What should I do next, why, and what happens after I approve it?”
The product does not stop at insight. It turns insight into an executable operating loop:
Financial evidence
→ Aurora-backed source of truth
→ deterministic forecast
→ customer memory
→ ranked recovery plan
→ tailored outreach
→ human approval
→ provider execution
→ audit trail
→ learned memory
→ better next action
Challenges I Ran Into
The hardest challenge was making autonomy safe.
A cashflow agent should be powerful enough to recommend and prepare action, but it should not silently contact customers, fabricate provider results, or invent financial totals.
I solved that by separating the system into clear layers:
- deterministic finance owns the money
- Aurora owns the truth
- AI owns reasoning, drafting, and learning
- humans own approval
- providers own execution evidence
- audit logs preserve accountability
Another challenge was making the product feel simple while the backend remained sophisticated. The user should not have to understand event inboxes, provider executions, or agent checkpoints. They should see a clean answer: here is your risk, here is the action, here is why, and here is what the system learned.
Accomplishments I Am Proud Of
I am proud that RunwayOps feels like a real product rather than a hackathon console.
A judge can open the deployed app and see a live cashflow overview, runway and payroll-risk storytelling, deterministic forecast scenarios, ranked recovery actions, customer-level intelligence, generated call scripts and outreach, approval-gated execution, provider readiness surfaces, an agent activity timeline, and learned customer memory.
Technically, I am proud of the Aurora-backed operating model. The system does not hide state inside prompts. It persists the facts, plans, approvals, provider events, memory, checkpoints, and audit trail in a real database architecture.
That makes the product feel much closer to something a finance team could actually use.
What I Learned
The biggest lesson was that agentic products need strong boundaries.
The impressive part is not letting an AI do everything. The impressive part is designing the system so the AI does the right things: explain risk, prioritize action, generate communication, retrieve memory, prepare execution, and learn from outcomes.
And the system keeps the critical things grounded: financial totals, approval state, provider execution, audit history, and customer memory.
That boundary is what makes RunwayOps trustworthy.
What Is Next
The next step is to connect RunwayOps directly to live accounting, banking, and CRM systems so it can continuously ingest financial reality without manual refreshes.
From there, I would expand the autonomous loop into supplier negotiation, rolling cash planning, financing recommendations, customer risk scoring, multi-user approval workflows, deeper LangSmith evaluation dashboards, richer provider execution and outcome learning, and production-grade team accounts, roles, and permissions.
The long-term vision is that every small business has an autonomous cashflow operator watching runway, learning customer behavior, preparing the next best action, and keeping the founder in control.
Safety, Privacy, and Control
RunwayOps is not a bank and does not move money.
It is designed as a cashflow operating assistant. Outbound action is approval-gated, provider-gated, and auditable. The system is built so financial truth lives in Aurora, provider outcomes are only shown when backed by provider state, and human approval remains part of the execution path.
Built With
- amazon-rds-data-api
- amazon-web-services
- aurora-postgresql
- aws-iam/oidc
- css
- fireworks-ai
- gmail-oauth-foundation
- langgraph
- langsmith
- next.js
- tailwind
- twilio
- typescript
- vercel
Log in or sign up for Devpost to join the conversation.