Case Study: Espresso Engage
By Grant Crawley · 5 June 2026
Enterprise-grade, six-repository SaaS platform, delivered in 398 engineering hours
Client/Partner: Screencult Ltd
Delivered by: virtco®, AI-augmented software development
Product: Espresso Engage, mobile-first employee engagement through bite-size video, hosted securely inside the customer's own Microsoft 365 tenant
Period: November 2025 – May 2026
Executive summary
Espresso Engage needed what would conventionally be a multi-year, multi-million-pound build: native iOS and Android apps with consumer-grade video performance, a creator and administration portal, a multi-tenant application programming interface (API), push notifications, and deep Microsoft 365 integration, all built to enterprise security and compliance standards.
virtco® delivered the entire six-repository platform in 398 actual engineering hours, against a COCOMO industry-model estimate of ~$2.19 million, 195 person-months, and a peak team of six. That is roughly a 75× effort advantage and a >95% cost reduction versus industry norms, without compromising on architecture, security, or polish.
This was not AI replacing engineering judgement. It was 30+ years of engineering judgement, amplified by AI. virtco®'s AI-augmented delivery model working exactly as designed.
The partnership
Espresso Engage is a product partnership between Screencult Ltd, who leads the video production, training and coaching side of the offer, including the "12-month enablement promise" that takes a customer from agency-produced content to full self-sufficiency, and virtco®, which conceived, architected and built the technology platform.
The problem
Corporate communication is losing the attention economy. Internal emails average a 15% click-through rate, only 13% of employees check the intranet daily, and meeting overload actively prevents 78% of employees from doing their work. Espresso Engage's answer is short-form, swipeable vertical video: the format employees already choose at home, delivered to the device in their pocket.
But the product brief carried several hard constraints:
- The experience had to feel consumer-grade. Employees would only adopt it if video playback, scrolling and discovery felt natural on mobile.
- Enterprise IT had to be comfortable. Customer content needed to remain within the customer's own Microsoft 365 environment, rather than being moved to an external video platform.
- Authentication had to be invisible. The experience had to respect existing corporate sign-in and access policies, with no new passwords and no shadow IT.
- The product had to support a real SaaS business. Marketplace onboarding, subscription management, tenant isolation and operational tooling were all required from the start.
The solution: six repositories, one platform
Espresso Engage was delivered as a coordinated six-repository platform, covering employee mobile apps, creator tooling, administration, backend services, notifications and operations.
| Repository area | Role | Principal languages and technologies |
|---|---|---|
| Native iOS app | Employee mobile experience | Swift |
| Native Android app | Employee mobile experience | Kotlin |
| Creator and admin portal | Web-based content and tenant management | TypeScript, Next.js |
| Backend services | Multi-tenant application programming interface | TypeScript, Node.js, MySQL |
| Notification service | Scheduled and targeted push delivery | TypeScript, Node.js |
| Operations portal | Internal platform administration | TypeScript |
The platform comprises 70,834 lines across the six repositories, of which roughly 14,200 lines are Markdown documentation. That documentation discipline was intentional: architecture notes, decision records and AI-agent working instructions gave the delivery process clear context and reduced ambiguity as the system grew.
Coding performance vs industry norms
The headline numbers
| Metric | Industry model (COCOMO) | Espresso actual | Advantage |
|---|---|---|---|
| Effort | ~195 person-months (~29,600 hrs) | 398 hours | ~75× |
| Cost | ~$2,193,000 | $2,500 AI compute + 398 senior hours | >95% saved |
| Team | Up to 6 concurrent engineers | 1 engineer, with a second joining from April, supported by AI agents | 6× leaner |
| Calendar | 13+ months modelled for the Android app alone | 11 days for Android delivery | ~36× faster |
Against published productivity benchmarks
Long-running industry research, including Capers Jones' work across thousands of software projects, puts sustained professional output at 325–750 lines of production code per developer per month, roughly 16–38 lines per day. Fred Brooks' classic figure is 10 lines per day, and even more generous modern estimates remain far below the pace achieved here (Successful Software, NDepend, DZone).
Excluding documentation, Espresso Engage shipped ~56,600 lines of production code in 398 hours, equivalent to ~142 lines of code per hour, or over 1,100 lines of code per 8-hour day. Even against the most generous traditional benchmark, that is a 20–70× throughput multiple, sustained across six repositories and several languages over six months.
Lines of code are an imperfect measure. They do not prove quality by themselves, and they can be inflated by boilerplate. In this case, they are useful because they sit alongside a concrete product outcome: native mobile apps, a web portal, backend services, tenant operations, subscription flows, analytics and enterprise integration delivered as one working platform.
Delivery shape
| Platform area | COCOMO estimate | Actual delivery | Outcome |
|---|---|---|---|
| iOS app | ~$490k · 10.5 months · 4+ people | 132 hours | Native employee app delivered |
| Android app | ~$895k · 13.2 months · 6 people | 88 hours | Full native Android app delivered in 11 days |
| Creator/admin portal | ~$390k · 9.6 months · 3+ people | 89 hours | Web portal for content and tenant management |
| Backend services | ~$194k · 7.4 months · 2+ people | 45 hours | Multi-tenant SaaS services and commercial flows |
| Notification service | ~$149k · 6.7 months · 2 people | 27 hours | Scheduled, targeted push delivery |
| Operations portal | ~$76k · 5.2 months · 1+ people | 17 hours | Internal administration capability |
The Android delivery is the clearest single example of the method in action: a complete native Android application was produced from the already-proven iOS product pattern in 11 days, using senior engineering judgement to guide AI-assisted implementation rather than manually rebuilding every feature from first principles.
Design principles and execution
The original build involved many detailed engineering decisions. This case study deliberately describes them at a higher level: enough to show the quality of the thinking, without publishing an implementation manual.
1. Customer-owned content by design
Espresso Engage's defining architectural decision is that customer video content remains inside the customer's own Microsoft 365 tenant. The platform is designed around the customer's existing content, identity and governance environment, rather than pulling media into a separate third-party hosting stack.
That choice makes enterprise adoption easier because the compliance answer is structural: data residency, access control and corporate policy are aligned with the tools the customer already uses.
2. Efficient media preparation without unnecessary infrastructure
Video processing is often one of the most expensive parts of a software-as-a-service (SaaS) product. Espresso Engage reduces that burden by moving appropriate media preparation closer to the creator experience, rather than relying on heavyweight server-side processing for every upload.
The result is a more efficient operating model: creators get a guided upload flow, while the platform avoids building and running an expensive media-processing backend before it is needed.
3. Large-file handling that respects enterprise platforms
Corporate video files can be large, and conventional web upload patterns are fragile at that size. Espresso Engage uses a brokered upload approach that allows the browser and the customer's Microsoft environment to handle large media reliably, while the Espresso platform coordinates the process and maintains the right tenant context.
The important principle is separation of responsibility: the platform manages workflow and permissions; the customer's Microsoft environment remains the system of record for the media itself.
4. Native mobile performance for workplace content
Short-form video only works if it feels instant. Espresso Engage was built as native iOS and Android software so the employee experience could take advantage of each platform's mobile performance characteristics.
The apps use platform-appropriate video playback patterns, careful resource management and offline-tolerant thinking to support smooth browsing on real employee devices and real corporate networks.
5. Deep Microsoft 365 integration
The platform integrates with Microsoft 365 for identity, content access and enterprise workflow. That integration is not a superficial sign-in button; it is part of the product model.
For customers, this means Espresso Engage can fit into existing information technology (IT) governance rather than becoming another disconnected tool. For employees, it means the experience feels familiar and does not require a separate set of credentials.
6. Scalable, considerate communication
Push notifications are powerful, but they need to be used responsibly. Espresso Engage includes a dedicated notification capability designed for targeted communication, operational resilience and employee context.
The emphasis is not just on sending messages, but on sending the right messages to the right people at the right time.
7. Security throughout the product
Security was treated as part of the architecture, not as a late-stage checklist. The platform was designed around tenant separation, corporate identity, role-aware access, secure mobile authentication and careful operational controls.
That matters because Espresso Engage is not a consumer experiment. It is a workplace communication platform intended for enterprise customers, procurement teams and IT stakeholders.
8. A SaaS business, not just an app
Beyond the employee experience, Espresso Engage needed the commercial and operational foundations of a real SaaS product: onboarding, billing, tenant management, branding, engagement analytics and internal support tooling.
Those foundations were built into the first platform release, allowing the product to move beyond prototype status into a commercially usable service.
How: the virtco® AI-augmented method
Every repository was built with agentic AI, including Claude and Google Gemini, directed by senior engineering judgement.
The method was simple, but disciplined:
- Specify before generating. Planning documents, architecture notes and working instructions gave AI agents precise context. The documentation was not overhead; it was part of the delivery system.
- Use proven architecture. The product used established engineering patterns for mobile apps, web applications, backend services and workers. AI accelerated implementation within those boundaries; it did not replace architectural thinking.
- Match the work to the agent. Different AI models were used where they were strongest, with senior engineers reviewing, directing and integrating the output.
- Measure continuously. Code, effort and modelled delivery baselines were tracked throughout, giving the case study its evidence base rather than relying on anecdote.
This is the central lesson of Espresso Engage: AI creates the most value when paired with experienced people who know what good software should look like.
What this means for your business
Espresso Engage is virtco®'s reference implementation of a claim most consultancies cannot yet back up: AI-augmented delivery changes the economics of custom software by an order of magnitude or more when it is driven by people who could have built the system the hard way.
The same approach applies to the systems your business needs: the integration you have been quoted six figures for, the internal tool considered too small to justify a team, or the product idea that looked as though it needed a year of runway.
If a 195-person-month platform can be delivered in 398 engineering hours, the conversation about what is feasible changes completely.
See the product: espressoengage.com
Start a conversation: virtco.com
Code metrics measured with Succinct Code Counter (scc) on 29 May 2026; cost/effort baselines are scc's COCOMO model output. Industry productivity benchmarks: Capers Jones via Successful Software, NDepend on Brooks' 10 lines of code per day, DZone: The Programmer Productivity Paradox. Lines of code are an imperfect productivity measure; figures are presented as directional evidence alongside architecture, scope and calendar facts.