Built by Filmmakers. Not AI.

For over two years, we have been developing CinePlatform, we have worked through countless late nights, to make film pre-production better for the people who actually make films.

There's a question that comes up more and more whenever a new piece of software appears, and one we’ve been asked directly and repeatedly by filmmakers we speak to: "Was this built using AI?"

For CinePlatform, the answer is simple. No!!!

Not a single line of code was generated using AI, and we don't use AI to power or operate CinePlatform.

In a world where entire applications can be quickly generated from a handful of prompts, saying loudly that CinePlatform was not built with AI, might sound like an unusual thing to be proud of.

It's because of what CinePlatform means to us, why we started building it in the first place, and the responsibility we feel towards the filmmakers who put their trust in it.

CinePlatform isn't just another piece of software to us. It's something we've poured years of our lives into, and we care deeply about getting it right.

We firmly believe there's something important about understanding what you're building, making your own decisions, and putting the time, knowledge and care into getting it right, something a simple prompt can't do.

The journey towards CinePlatform as it is today, started with a problem, our own problem.

Before CinePlatform existed, we were filmmakers trying to organise our own productions, trying to wrangle people, write scripts, manage the arduous, stressful and time consuming admin that comes with every film.

We knew the frustrations well, we lived them, scripts in one place, shot lists somewhere else, schedules scattered across spreadsheets and documents, call sheets being passed around through chat groups, and important information buried in messages and emails.

We understood how much time could be lost simply trying to keep everyone organised and working from the same information. We know how much time could be lost, because we've lost it ourselves. Time that could have been spent developing ideas, working with actors, planning shots or actually making films; The fun side of filmmaking.

Instead, we were spending it chasing details, updating spreadsheets, copying details between documents and trying to make sure everyone knew what was happening and everyone was working from the same information.

And we kept coming back to the same thought. There has to be a better way to do this, so we started building one.

Not because we'd identified a fashionable market to enter. Not because we wanted to launch another subscription service. But because we wanted a system that we'd actually want to use on our own productions.

That idea became CinePlatform.

Over two years and many thousands of hours, CinePlatform didn't appear overnight.

It's the result of more than two years of writing code, designing interfaces, solving problems, testing features, fixing bugs, rethinking decisions and occasionally starting things again when we knew they could be better.

It's been built around day jobs, family commitments, evenings, weekends and more late nights than we'd care to count, seeing the clock tick over to 4am has become a regular occurrence.

There have been so many moments of frustration, features that seemed straightforward until we started building them, problems that took days to solve, ideas that looked great on paper but didn't quite work in practice.

And plenty of occasions when laptops got closed, only to open them again 15 minutes later because we couldn't stop thinking about how to make something better.

That's the reality of building something you care about, there's no magic button, no prompt that produces two years of understanding, no shortcut to knowing why a particular feature matters to the person using it.

Just a lot of hard work, persistence and a genuine belief in what we're creating, and we wouldn't have it any other way.

The rise of the "vibe-coded" app

We're seeing more and more applications appearing online that have been created almost entirely through AI prompts.

Some of the results are quite impressive… but impressive for the wrong reasons.

It's often referred to as "vibe coding", where someone describes what they want an application to do and allows AI to generate much of the code for them, if not all of the code.

And increasingly, we're seeing these applications being launched by people who have little or no experience in software development, no knowledge on how to support them, their entire bug fixing and support structure being to "ask AI to fix it"

Don't get us wrong, it's remarkable that technology has reached a point where someone without programming knowledge can create something functional, occasionally very impressive. And making technology more accessible isn't inherently a bad thing. But there's an important distinction that we feel is getting lost in the excitement.

There's a vast difference between generating an application and engineering a platform

Building software isn't just about making buttons work or creating something that looks impressive in a demonstration.

It's about understanding what happens behind the scenes, how information is stored and protected, how different parts of a system communicate and how it performs under pressure.

And understanding the technology well enough to know what happens when something goes wrong, and how the software can be maintained, improved and supported over time.

It's about understanding the consequences of the decisions you make during development, including the ones that might not become apparent for months or years, and certainly until you have people using the software and experiencing problems.

AI can generate code, but generating code doesn't automatically provide the person using it with the knowledge to evaluate whether that code is appropriate, secure, efficient or maintainable.

Robustination

When you're building software that people will come to rely on, those things really matter. We're not suggesting that every AI-generated application is poorly built, or that people without traditional development experience can't create useful tools.

But, aside from the conversation about responsible use for the environment on the use of AI, there's a strong difference between getting something working and truly understanding what you've built.

A dependable platform is what matters. CinePlatform has been built with that distinction firmly in mind.

In fact just 8 months ago, we went back through what we’d built, a process we’ve come to call robustination, and went through the code line by line, library by library and ensured every piece was secure, reliable, robust and up to date with the way we write the platform today.

Behind CinePlatform is over 30 years of software development experience, firmly combined with our own experience working in filmmaking.

That matters to us because we're not just creating something that needs to look good today. We're building something that needs to keep working tomorrow, next year and beyond. We're building something that we know, if an issue becomes apparent today, it'll be fixed tomorrow.

Built with filmmakers, not just for them.

One of the most important parts of CinePlatform's development hasn't been the code. It's been the conversations.

We've spent time listening to filmmakers, understanding how they work, what frustrates them and what they wish their existing tools could do. We've listened to people working on productions of different sizes, with different responsibilities, challenges and ways of organising their work. We’ve partnered with educational organisations, producers, directors and gained valuable feedback, suggestions and ideas and moulded CinePlatform into what it is today.

Features have changed, some of them dramatically because of those conversations, our entire scheduling system was rewritten based on dozens of conversations, workflows and interfaces we've built and have been reconsidered, and new ideas have emerged from something as simple as a filmmaker asking, "Wouldn't it be useful if...?"

Every part of CinePlatform has been shaped by an understanding of real production work, that understanding comes from filmmakers we've spoken to, it comes from our own experiences with preparing for a shoot.

Why we haven't used AI

As technology evolves, there are plenty of interesting conversations to be had about if and where AI belongs in creative industries and software development. AI is a powerful tool, and saves a lot of time in some circumstances and if there can be a responsible way to use it it could be helpful.

But we made a choice about how we wanted to build CinePlatform. We wanted to understand the system we were creating. Every feature, every workflow, every connection between different parts of a production. We wanted the decisions behind those features to come from experience, feedback and an understanding of the people who would use them. For those reasons using AI in pulling this system together was not an option.

We wanted CinePlatform to remain a tool that supports filmmakers, rather than one that tries to make their creative decisions for them.

CinePlatform doesn't need AI to be useful or powerful.

CinePlatform needs to be reliable. It needs to be thoughtfully designed. It needs to make sense to the people using it.

It needs to work first time, when you're on a set or trying to prepare a production and something doesn't work, you need to trust that real people are behind the software, not someone prompting an AI to figure out what's gone wrong, and not understanding how today's prompt will affect tomorrow's work.

It needs to solve real problems, that's where we've put our energy. We're still talking to filmmakers every day, and we're still building.

One of the things we've learnt over the past two years is that there's always something we can improve.

A workflow we can simplify, a feature we can expand, a problem we haven't encountered yet, that's exciting to us.

CinePlatform isn't something we've built, put on a shelf and declared finished. It's an evolving platform, and the people using it are helping shape where it goes next.

We want filmmakers to tell us when something works brilliantly, but also when it doesn't. We want to hear about the frustrations, the missing features and the little things that would make someone's production day easier.

We're not interested in pretending we have all the answers. We're interested in building a platform that keeps getting better. More than just lines of code

At the end of the day, CinePlatform is software.

It's code, databases, interfaces and countless technical decisions working together to help organise film productions, but to us, it's also something much more personal.

It's two years of our lives. It's the ideas we've had, the mistakes we've made, the problems we've overcome and the things we've learnt along the way, it's the filmmakers who've given us their time, shared their experiences and helped us understand what this platform could become.

It's the late nights when we could have called it a day but decided to keep going, and it's the belief that independent filmmakers deserve professional, accessible tools built around the way they actually work.

CinePlatform wasn't generated, it was built, by filmmakers, with filmmakers, for filmmakers.

And we're only getting started.