I work a lot with the cruise ship industry, and one of the more interesting challenges we run into is that often there are user-facing systems that have to work without an Internet connection. I’ve designed applications that are supposed to work in a mine, or on a plane, and then later sync with the cloud, but building something that might not have a web connection for three days through the fjords  is a little different.

We’ve been looking into sending local notifications without any Internet access at all – from a server installed locally on the ship, to an app on a crew member or guest’s personal device. The basic idea is that an app, installed on the phone or tablet, can send a “local push notification” or “background push notification” to the operating system. Even if the app is not in the foreground, or the phone is asleep, the notification should wake the device up, and present the user with a message. This is exactly the same as a standard push notification (think Facebook or calendar notifications), but instead of using Apple’s push server, you are using an app itself to send the message. The problem is how do you trigger the app to do something in the background? The app has to wake up in the background, contact the local server, check for messages, download any available message or content, and then alert the user if it found anything.

There are a couple of ways to trigger a background application to do something for you. The two we looked into for our purposes were “Location Updates” and “Background Fetch”

Our limitation here is obviously the cellular modem will be turned off (Airplane mode) because there either is no cell tower around, or you don’t want your passengers paying international data roaming fees. There are other ways to trigger a background app action, but they mainly involve things like plugging in headphones, managing VoIP calls, and mainly Internet-requiring services. You can read more about the available options here: http://apple.co/29288f1

Option 1. The background fetch function appears to be the best option for this kind of app. This is something we’ve used in the past, but never had to worry about sans-Internet issues. The way background fetch works is the operating system puts your app into a queue of other apps asking for background services. The queue is processed based on which apps have the best efficiency. Apple does not really go into details, but it appears that the less data and the less battery your application uses in the background, the more frequently your app will be given background privileges (http://apple.co/291iAkd).

However, the problem here was we didn’t know exactly how efficient the application will be before we build it and start tuning it. So we built a prototype. While plugged in to a charger, it was able to receive messages every 10-12 minutes. Unplugged it was able to check the server only ever 20 minutes.

Option 2 (Augmentation). So in order to augment the inconsistent/unknown response time of the background fetch, we looked at the location updates. Location Updates are a way of triggering a background function when the device detects “a significant location change”. The idea is that if the phone detects movement that is “significant” (whatever that means) it will trigger your app. This is not exactly well documented but through some research and some experimentation it appears that “significant” means 1000 meters. This would be perfect for us, because seeing as while on a cruise you are probably moving 10 meters a second, we could have the app update every minute and a half. That would be an additional update cycle to cut down on the 10-minute maximum update cycle. The problem is that this measurement is tracked using the cellular antenna, and not the GPS! After a fair amount of banging our head on the desk, we gave up on Option 2.

As far as I know, planes and cruise ships are going to be relegated to the notification abyss for the time being. Without reliable Internet access, devices can’t get timely push notifications. The limitations on local push notifications while in airplane mode might be ok for notifying crew about training drills and passengers about dinner times, but it would not be reliable enough for emergency notifications.

Previous ArticleNext Article
I help companies turn their technical ideas into reality. CEO @Sourcetoad and @OnDeck. Author of Herding Cats and Coders. Fan of squash, whiskey, aggressive inline, and temperamental British sports cars.

Leave a Reply

Don’t Fall Into the Trap: Why Startup Software Development Isn’t Like Corporate Development

In Startups, Technology

So, you’ve left the corporate world, and now it’s time to build your own startup. You’ve probably managed dev teams before, overseen product launches, maybe even helmed some fancy project management tools that made everything run like a well-oiled machine. You’ve done this before, right? Not exactly. When it’s your startup, everything changes—and, as I’ll explain, if you assume it’ll work the same way, you’re heading for a few surprises.

Startup founders often fall into a dangerous trap when starting a software project from scratch: thinking it’ll be just like building software inside an established company. Here’s why it’s not—and some advice on how to navigate the differences.

1. Switching from Product Manager to Teacher

In an established company, a software team already has two things that give them a serious edge: an existing market and a deep understanding of the business. They’re working within a proven model. Developers in that environment know what questions to ask, can fill in gaps intuitively, and likely understand why they’re building what they’re building.

At a startup, however, your devs are going to need a whole lot more context. They’re not working with familiar requirements—they’re working with your vision, which may be abstract at this stage. If your development team doesn’t understand why something matters, it’s a recipe for ambiguity and frustration on both sides.

Advice: Think of yourself less as a product manager and more as a teacher. Your job is to make sure they understand the core problems, not just the features. Teach them why each requirement matters, help them visualize the end-user, and create that shared language for decision-making. It might feel tedious, but it’s essential to avoid future misalignment and expensive rewrites.

2. Beware of Perfectionism — It’s the Budget Killer

In a large company, products with an existing user base often have to be polished. Features need to be rock-solid, invoices have to be perfect, and everything needs an audit trail. Startups, however, have a different goal: get an MVP in the hands of users fast. It’s a classic trap for first-time founders—focusing on “perfection” and “polish” before knowing if the business model even works.

Startup perfectionism is budget poison. It’s shocking how quickly adding “nice-to-have” features can chew through funding, especially if you’re paying a dev team to build things like automated invoicing or churn management before you’ve even proven people want what you’re selling.

Advice: Ruthlessly strip down your MVP. If a feature doesn’t help you validate your market, it goes on the “later” list. Keep the scope laser-focused on what helps you test your business assumptions. Let the non-essential features wait until you know you have customers who’ll use them.

3. Zen and the Art of the Startup Pivot

Building software for a startup means embracing one cold, hard truth: the business model will change. According to research, 93% of successful startups pivot at least once (and often more). Imagine being asked to go out and passionately sell something that you know might not look the same next year—or next month. It takes a level of zen acceptance that your original idea will likely morph, but that’s what keeps you flexible and ready to capture new opportunities.

For founders, that requires a mindset shift. You have to believe in your product, while also knowing you might be building the “wrong thing” in some way. The focus should be on preserving capital and brainpower for what’s next. The game is less about proving you’re right and more about staying adaptable.

Advice: Budget with pivots in mind. Set your burn rate assuming you’ll need to make big changes. Don’t let ego get in the way of listening to the market, and keep enough gas in the tank for at least one big strategic turn.

4. The Hard Work of Being Your Own “Internal Customer”

Here’s another big one. In a corporate environment, you have internal customers—departments or stakeholders with specific goals that align with the overall company mission. For a startup, the only customer you have is you. You don’t have a preexisting feedback loop from various departments, and you don’t have established success metrics. You have to create that from scratch.

Advice: Start by building an internal customer profile based on your target market, then use that to set clear goals and success criteria for your dev team. If you’re focused on, say, usability for early adopters, set KPIs around usability testing and build from there. By acting as your own “internal customer,” you’re setting a clear direction and saving your team from working in a vacuum.

5. Get Ready to Build AND Sell

Corporate software development often has the luxury of a separate, dedicated sales team to deliver the product to the right audience. As a startup founder, you’re both the builder and the seller. That means you’re not just iterating on software—you’re iterating on messaging, product-market fit, pricing, and maybe even distribution models.

Advice: Factor in time for sales-ready iteration in your dev cycle. As you build, keep track of how each release or update affects the user experience. Ask yourself if the changes make your pitch clearer or simpler and how they align with the current market’s needs. Ultimately, this approach will help you bridge the gap between building the product and ensuring it’s market-ready.

Conclusion

Building software as a startup founder requires a whole different toolkit than you may be used to. You’re part-teacher, part-salesperson, part-zen master, and always the chief budget officer. By recognizing the unique mindset shifts and traps of startup software development, you’re positioning yourself—and your team—for the best chance of success. Focus on creating clarity for your team, set ruthless priorities, embrace change, and never lose sight of the fact that the first version is just the beginning. In the startup world, adaptability isn’t just a skill—it’s the entire game.