How Built Galaxy Movies: From a Side Project to a Cost-Conscious Streaming Discovery Platform

How Built Galaxy Movies: From a Side Project to a Cost-Conscious Streaming Discovery Platform

●24 ●48 ●141
calendar_today • schedule14 min read
📝 DEV STORY
Nick Fasulo Featuring: Nick Fasulo • Developer

Interviewed by: Mehadi Hasan

Developer: Nick Fasulo

Role: Software Developer

Location: Los Angeles, California

Featured Project: Galaxy Movies

A Side Project That Became Something More

Building a software product is not just about getting features to work. It is also about keeping infrastructure costs under control, protecting external API quotas, making reliable data available, and helping users discover something genuinely useful.

For Nick Fasulo, these challenges became central to the development of Galaxy Movies, an open-source movie and TV discovery application designed to answer two practical questions: What can I watch on the streaming services I already pay for, and what should I watch before it disappears?

What began as a personal experiment with infinite scrolling eventually evolved into a production application with streaming availability data, watchlists, email alerts, an AI chatbot, and a paid Plus tier. Much of the application's current functionality was built during an intensive month of development after Nick returned to a project that had remained dormant for years.

His journey offers a useful perspective on independent software development, particularly for developers working with limited budgets. Rather than treating cost, infrastructure, and technical constraints as problems to solve later, Nick has made them part of the application's design from the beginning.

An Unconventional Path Into Software Development

Nick did not follow the traditional computer science degree route. His formal software development training began with Fullstack Academy's Software Engineering Immersive in 2021, followed by General Assembly's Web Development Immersive in 2023.

He gained practical experience through a React frontend internship at Yup.io and a Shopify development internship at Stasis, where he worked on real storefronts. These early experiences helped him move from learning web development concepts to building software that people could actually use.

His subsequent career took him beyond conventional frontend development. At UBS, he worked as a data specialist in SQL-heavy financial systems. Later, at Bright Data, he became a technical support manager responsible for handling complex issues involving web scraping APIs and proxy networks.

Although the move into technical support might have appeared to be a detour, it became one of the most influential parts of his engineering journey.

At Bright Data, Nick spent his time investigating HTTP requests, reproducing integration bugs, and understanding how traffic moves through the web. That experience gave him a practical understanding of API behavior, rate limits, and crawler defenses.

Those lessons would become especially valuable when Galaxy Movies began handling real traffic and faced abuse against its API endpoints.

His experience illustrates how skills gained outside a traditional software engineering role can translate directly into stronger engineering decisions. Understanding how systems behave under difficult conditions can be just as important as knowing how to build their features.

Galaxy Movies: Solving a Problem Every Streaming Viewer Understands

Galaxy Movies began approximately four years ago as a small experiment. Nick wanted to explore infinite scrolling, and a movie catalog provided a convenient way to experiment with the interface.

The project eventually stalled as other responsibilities took priority.

When Nick returned to it, he had a clearer idea of what the application could become. He was frustrated by the difficulty of tracking movies across multiple streaming platforms. Titles appeared on one service, disappeared from another, and often left viewers unaware that something they wanted to watch was about to become unavailable.

Instead of building another movie catalog, he decided to focus on streaming availability and the changes happening across different services.

Galaxy Movies now tracks additions, removals, and upcoming departures across 16 US streaming services, with a growing catalog for India. It also provides provider-specific catalogs, genre browsing, title search, streaming availability information, and monthly lists of arriving and departing content.

The underlying idea is straightforward: streaming availability should be useful, current data rather than a detail buried inside individual entertainment platforms.

The application brings that information together so viewers can make better decisions about what to watch and when to watch it.

Building a Connected Set of Features Around One Data Pipeline

Galaxy Movies includes several features designed to help users discover content and keep track of changes.

Users can browse catalogs by streaming provider and genre, search for titles, and check where movies and shows are available. They can also maintain watchlists and receive email alerts when titles become available on their selected services.

The application includes an AI chatbot for conversational movie discovery, an RSS feed covering streaming departures, shareable lists, and an embeddable widget that other websites can integrate into their pages.

A paid Plus tier adds additional alert types, including departure notifications, taste-based recommendations, and episode air dates. It also offers Trakt and Letterboxd synchronization and higher usage limits.

However, the feature Nick is most proud of is not a user interface or a standalone product capability. It is the streaming-changes engine that powers much of the application.

A scheduled job takes snapshots of each provider's catalog and calculates the differences between them. Those changes become the foundation for the site's departure pages, streaming availability indicators, alert matching, RSS feed, social cards, embedded widget, and even a Reddit trivia game.

This approach means that multiple features can rely on the same underlying dataset rather than implementing separate mechanisms for tracking availability.

As Nick explained in his interview, getting the data right once allows downstream features to benefit from that work.

For a small independent project, this is an important architectural choice. A reliable shared data pipeline can provide more long-term value than building each new feature as an isolated system.

Why Nick Moved From Vercel to Cloudflare Workers

As Galaxy Movies developed into a more substantial application, infrastructure costs became harder to ignore.

Nick had initially hosted the application on Vercel, but its pricing no longer made sense for a side project with growing usage. Cloudflare Workers had become a viable alternative for running Next.js through the OpenNext adapter, making migration possible.

The move involved more than transferring the main application. Nick migrated server-side rendering, scheduled jobs, incremental static regeneration, and dynamically generated Open Graph images.

The process exposed several runtime differences that required specific solutions.

Cloudflare Workers does not provide Node.js's TCP networking stack, so code that depends on it needs an alternative. Services such as Upstash, OpenAI, and Resend were easier to retain because they support REST APIs.

Other components required more substantial adjustments. Runtime WebAssembly and filesystem restrictions broke the Open Graph image route until Nick conditionally imported the edge-compatible build. Vercel cron jobs also needed to be replaced with a generated scheduled handler, while the incremental static regeneration cache required an R2 bucket.

These issues demonstrated that compatibility at the framework level does not guarantee that every part of an application will work in a different runtime.

One of Nick's most important lessons came from testing. Standard builds passed, but the application could still crash when executed inside the actual Workers environment.

He responded by changing the deployment checks. His CI process now boots the built application under the real Workers runtime and runs smoke tests before deployment.

That test has caught more problems than the other checks combined, according to Nick.

The experience reinforces a practical principle for developers adopting edge platforms: test the application in the environment where it will actually run, not just in a development environment that may behave differently.

Designing Around Free-Tier Limits Instead of Hoping for Low Bills

Nick's approach to infrastructure extends beyond choosing a cheaper hosting platform.

He prefers hard usage limits over unpredictable, open-ended pricing. A service that stops at a defined limit may be easier to manage than one that continues charging as traffic grows, especially when an independent project can receive unexpected bursts of requests.

Galaxy Movies uses several techniques to keep that risk manageable.

For Redis, where billing counts individual commands, including commands inside pipelines, Nick designed request paths to reduce unnecessary operations. The implementation uses hash storage instead of per-key fan-out, batches counters in memory before flushing them, and avoids casual reads on frequently accessed paths.

The application also tracks upstream API quota information from response headers. It begins refusing requests when usage reaches 90 percent of the available quota and suspends scheduled jobs at 99 percent, helping preserve the remaining capacity.

Nick has also built a private usage dashboard that aggregates worker, database, AI, and billing information. This gives him a way to monitor consumption rather than discovering unexpected costs after receiving a bill.

These decisions reflect a broader engineering philosophy: cost control is not simply a finance task. It influences how software should be designed.

For developers building side projects, this can mean thinking carefully about how often a request touches a database, whether a background job is necessary, how repeated work can be cached, and what happens when an endpoint receives far more traffic than expected.

Nick's experience suggests that these questions are worth addressing before a project becomes expensive to operate.

When API Abuse Becomes an Infrastructure Problem

One of the most difficult challenges Nick encountered was abuse against Galaxy Movies' API endpoints.

Some endpoints made requests to upstream providers, so excessive traffic could consume external API quotas and database resources. The incoming requests appeared to come from clean browser user agents and rotating IPv6 addresses, with traffic distributed across proxies.

Traditional per-IP rate limits were insufficient because the requests did not originate from a single stable address.

Nick drew directly on his experience at Bright Data to address the problem.

Rather than relying on one defensive measure, he introduced multiple layers of protection.

The application persists provider quota headers and stops making upstream calls when usage crosses the 90 percent threshold. A global hourly budget acts as a circuit breaker for the flood of requests.

When that budget is exceeded, each edge isolate denies requests for 60 seconds without contacting Redis. This detail matters because the system should not incur additional database costs merely to reject requests generated by the abuse itself.

A crawler policy at the CDN layer provides another level of protection.

The approach prioritizes keeping the application operational within its resource limits rather than assuming that more server capacity will solve every traffic problem.

For a small application running on free or low-cost infrastructure, protecting quotas and preventing unnecessary database operations can be just as important as protecting the application server.

Adding an AI Chatbot Without Sacrificing Accuracy

Galaxy Movies' AI chatbot emerged from the way people naturally search for entertainment.

A user might ask, "What's a good heist movie on Hulu?" or "Is The Bear still streaming?" These questions are conversational, and ordinary filters can make them awkward to express.

The chatbot lets users describe what they want in natural language. But implementing the feature introduced a significant technical challenge: keeping answers grounded in current streaming data.

A language model might confidently claim that a movie is available on a service even after the title has left its catalog. For a streaming discovery application, that kind of error undermines the product's main purpose.

Nick designed the chatbot so it does not rely on the model's memory to answer availability questions. Instead, it detects intent patterns, adds real provider data and the site's own streaming-change records to the context, and resolves titles mentioned in responses into actual links in the interface.

Responses stream token by token to make the interaction feel faster.

Cost and predictability also influenced the implementation. Since AI API calls represent a real expense for a hobby-budget application, Nick introduced layered rate limits and caching for repeated generations.

He deliberately kept some parts of intent detection simple. In his view, predictable behavior is more valuable than unnecessary cleverness for a feature that needs to return useful, trustworthy answers.

This is a useful distinction for developers building AI-powered products: a model can generate the response, but the application still needs to control which facts the model receives and how those facts are used.

Email Alerts Without a Traditional Login System

Another interesting design decision involved the watchlist alert system.

Nick wanted users to receive notifications when a title on their watchlist became available on a selected streaming service. Building this feature around a conventional account system would have required passwords, sessions, and account recovery flows.

Instead, he used email confirmation as the starting point for establishing identity.

After confirmation, the application generates a synchronization key and returns it in the URL fragment. Because the fragment is handled by the browser rather than included in the HTTP request sent to the server, the key stays out of ordinary server request logs.

Devices store the key to synchronize watchlists, ratings, and streaming-service preferences. A device-linking flow allows users to add a second device, while a separate token supports unsubscribing from individual lists.

When Nick later introduced the paid tier, the existing email-and-key mechanism became the basis of the login experience. The payment provider also associates the email address at checkout, preventing a different payment email from unintentionally creating a separate account identity.

Nick acknowledges that this design would not necessarily be appropriate for an enterprise application. For a consumer product, however, it removes a major point of friction: requiring someone to create an account before they can use a useful feature.

The lesson is not that conventional authentication is unnecessary. It is that authentication and account infrastructure should match the product's actual requirements rather than being added automatically.

Launching the Product Was Only the Beginning

Galaxy Movies had technically existed for years, but its recent transformation was effectively a relaunch.

Nick brought the application to Product Hunt and several other launch platforms and directories. The experience reinforced an important distinction: shipping software and getting people to discover it are separate challenges.

At the time of the interview, Galaxy Movies had received roughly 160 organic clicks over the preceding 28 days, with most landing on a single title page that had gained search visibility.

The alert system and Plus tier were implemented and tested end to end, but the only accounts using them were Nick's own test accounts. Real customer conversion therefore remained unproven.

Rather than treating launch-day attention as the ultimate measure of progress, Nick focused on improving the application's organic search visibility.

His work included refining sitemaps so they contained only pages worth indexing, sending IndexNow notifications when catalogs changed, and using Google Search Console to understand which pages Google had actually discovered.

Early visitors also exposed issues that testing had missed, particularly region-specific streaming data and unusual title matches.

Those problems highlighted something that can be easy to overlook when building a technically sophisticated product: users primarily care whether the information is correct and useful.

A well-designed architecture matters, but stale availability information can quickly damage trust.

Nick's next priorities reflect this reality. Rather than adding features simply to expand the product, he plans to concentrate on distribution, monetization, and making the existing dataset more valuable.

That includes expanding affiliate opportunities, improving provider-specific discovery pages, reaching out to librarians and entertainment writers, and extending regional coverage beyond the United States and India.

What Nick Learned From Building on a Limited Budget

Across Galaxy Movies' development, several lessons emerge from Nick's experience.

First, keeping infrastructure costs low requires more than selecting free services. It requires understanding how the application consumes those services and designing around their limits.

Second, architectural decisions should remain reversible whenever possible. Nick keeps his previous hosting environment configured as a cold standby, so returning to it would require only a DNS change. This provides a practical fallback if the new deployment encounters serious problems.

Third, reliability work deserves attention early. The streaming-change engine, deployment smoke tests, usage dashboard, and working unsubscribe flows all protect important parts of the product. They may be less visible than new features, but their value compounds over time.

Finally, unfinished projects can still have potential. Galaxy Movies remained dormant for years before Nick returned to it and turned it into a more complete product during a focused month of development.

His advice to developers who feel overwhelmed by hosting costs, infrastructure choices, or the amount of work required to launch is straightforward: start with the smallest version that solves a real problem, use a familiar technology stack, and treat free-tier limits as part of the design specification.

Building within constraints can force developers to understand the real cost of each request, the purpose of every background job, and the trade-offs behind their infrastructure decisions.

Those habits remain useful even when a product grows beyond its initial budget.

Looking Ahead: Turning Streaming Changes Into a Valuable Dataset

Nick's longer-term ambitions for Galaxy Movies extend beyond becoming another place to browse movies and television shows.

Over the next year, he hopes to establish consistent revenue from the monetization options already wired into the application, bring the alert list closer to 1,000 subscribers, and improve the search visibility of its programmatically generated pages.

Over a three-to-five-year horizon, he sees potential in the accumulated history of streaming availability changes.

A growing record of what arrived, disappeared, and changed across streaming platforms could eventually become useful to studios, distributors, entertainment publications, and other organizations interested in understanding streaming catalogs.

That possibility depends on whether the dataset proves valuable to audiences beyond ordinary viewers. Nick is self-funding the project and intends to maintain that approach, with operating costs kept near zero.

The strategy connects the technical architecture to the business model. The same underlying data that powers the consumer application could also support feeds, widgets, and other distribution channels that bring the information to additional audiences.

Rather than relying exclusively on new features to attract users, Nick is building around a dataset that becomes more useful as its history grows.

The Bigger Lesson: Constraints Can Improve Engineering

Nick Fasulo's journey with Galaxy Movies demonstrates how a side project can evolve when a developer returns to it with a clearer problem to solve and a willingness to address the operational details.

His experience spans frontend development, SQL-heavy systems, API integrations, edge deployment, AI grounding, abuse mitigation, and product distribution. These are not separate concerns in an independent application. They interact, and decisions in one area can affect the reliability and cost of everything else.

His most important lesson is that constraints can lead to better engineering decisions.

A limited budget encourages careful resource usage. Strict quotas make request costs visible. Runtime differences expose assumptions hidden by familiar development environments. And real users reveal problems that internal tests cannot always anticipate.

As Nick puts it, unfinished projects are not necessarily dead projects. Sometimes the next step is not to find a better idea, a more expensive stack, or the perfect time to begin. It is to take an existing idea seriously, build the smallest useful version, and keep improving it based on what actually happens.

Galaxy Movies is still working toward its longer-term business goals, but its development already illustrates an approach that other independent developers can learn from: build around a real problem, keep the architecture practical, and make every technical decision earn its place.

About Nick Fasulo

Nick Fasulo is a software developer based in Los Angeles, California. His experience includes React and Shopify development, SQL-heavy financial systems, and technical support for web scraping APIs and proxy networks. His technical interests include Next.js, JavaScript, serverless infrastructure, and AI-powered applications.

He is the developer behind Galaxy Movies, an open-source movie and TV discovery application that tracks streaming availability, helps users manage watchlists, and provides alerts when titles become available or are about to leave a service.

Developer Stories is a CoderLegion interview series highlighting the people, ideas, and engineering decisions behind software development.

Want more #devstories deep dives?

Join 5,946+ developers sharing real benchmarks, code breakdowns, and projects. Free forever.

2 Comments

3 votes
2 votes

More Posts

From Kubernetes Security Blind Spots to Verifiable Evidence: How Arif Kurnaz Built Attestkeep

Mehadi Hasanverified - Nov 1

Breaking the AI Data Bottleneck: How Hammerspace's AI Data Platform Eliminates Migration Nightmares

Tom Smithverified - Mar 16

How I Built a React Portfolio in 7 Days That Landed ₹1.2L in Freelance Work

Dharanidharan - Feb 9

I’m a Senior Dev and I’ve Forgotten How to Think Without a Prompt

Karol Modelski - Mar 19

Cisco's Amy Chang: A Model's "Passport" Doesn't Tell You Where It Actually Came From

Tom Smithverified - Aug 27
chevron_left
6.1k Points • 213 Badges
20Posts
262Comments
323Connections
About Me:
I serve as the Content Manager at CoderLegion, where I oversee the quality, clarity, and a... Show more

Related Jobs

View all jobs →

Commenters (This Week)

1 comment

Contribute meaningful comments to climb the leaderboard and earn badges!