Inspiration
A few years ago, I rediscovered the disposable camera.
There was something special about taking a photo and having no idea how it turned out. You couldn’t retake it ten times, edit it immediately, or sit there deciding if it was good enough to post.
You took the photo, moved on, and eventually got to experience that moment again when the photos were developed.
That anticipation made those photos feel different. They weren’t just pictures. They became memories.
Of course, now we can take hundreds of photos on our phones and instantly upload them to social media. We can take the same picture 20 times just to get the perfect one. But somewhere along the way, I think we lost some of the rawness that made photos like these special.
That’s where Vignette – Shared Camera came from.
I wanted to take that feeling of a disposable camera and turn it into something you could experience with everyone around you.
One click and BOOM! The photo is gone.
No preview. No deciding whether you like it. No deleting it and trying again.
It stays hidden from everyone until the event ends.
Then the event ends and everything gets developed at once. Now you have photos from different people, different perspectives, and completely different moments all sitting in one shared gallery.
You don’t just get the photos you remembered taking.
You get to discover the moments you missed.
What it does
Vignette – Shared Camera basically turns an event into one giant disposable camera that everyone shares.
A host creates an event and gets a unique event code. Friends join with that code, open the camera, and start taking pictures throughout the event.
But the important part is what happens after someone presses the shutter...
Nothing.
There’s no gallery to immediately check. You can’t sit there wondering if the photo was perfect. You take it and it disappears into the event.
Then you keep going.
Instead of everyone standing around looking through the pictures they just took, the idea is to put the phone back down and actually enjoy what’s happening.
Once the event ends, all of those photos are finally revealed together in one shared gallery.
A birthday could have 10 completely different perspectives. On a road trip, someone might capture something the rest of the group never even noticed. Weddings, vacations, parties, or just a random night with friends can turn into a collection of moments captured by everyone who was actually there.
Vignette isn’t about getting the perfect photo.
It’s about capturing what actually happened.
How we built it
I built Vignette natively for iOS using Swift and SwiftUI. From the beginning, I wanted the camera to be fast and the app to stay simple.
Supabase powers the backend and handles authentication, events, guests, photo metadata, and photo storage.
Each event gets its own unique code. That lets someone create an event, send the code to their friends, and have everyone start contributing photos to the same place.
One of the interesting parts of building Vignette is that I’m intentionally uploading photos that I don’t want the user to immediately see.
Normally you upload a photo because you want to display it somewhere. Here, I had to build the whole system around storing those photos while keeping the actual gallery locked until the event ends.
I also built the supporting website for Vignette with the landing page, support, privacy policy, terms, and everything else needed around the app.
There’s a lot going on behind the scenes, but I don’t want someone using Vignette to have to think about any of it.
Create an event.
Invite your friends.
Take pictures.
That’s it.
Challenges we ran into
I learned pretty quickly that photos get complicated.
One event can easily have hundreds of photos, and eventually I want Vignette to be able to handle thousands. Those photos are also coming from different phones with completely different network conditions. Someone might be on great Wi-Fi, while someone else might be at an event with barely any service.
I had to think about upload reliability, storage limits, large galleries, caching, image loading performance, and what happens when someone closes the app or loses connection in the middle of everything.
Another challenge was figuring out how much of the disposable-camera experience I actually wanted to keep.
We’re so used to taking a photo and immediately looking at it. If we don’t like it, we delete it and take another one. Vignette intentionally breaks that habit.
You can see everything normally through the camera while you’re taking the picture, but the second you press the shutter, that photo is gone. You don’t get to review it, delete it, or decide that everyone needs to stand there while you take five more.
You just have to trust the photo and keep going.
That limitation is really what makes Vignette feel like Vignette. If I start adding ways to review and retake everything, eventually I’ve just built another camera app.
Building this solo also meant I needed people other than me to actually use it. My friends and family basically became my QA team.
I started taking Vignette everywhere I could. A day at the beach became an event. A trip to the US Open became an event. A random trip to Savannah became an event. Instead of only testing Vignette while sitting at my desk, I got to see what happened when people actually used it throughout a real day.
And they broke things.
They tapped things I didn’t expect them to tap, did things in orders I didn’t expect, used it with terrible service, and found problems that I probably never would have found testing the app by myself.
Every time that happened, I went back and figured out how to make that part of the app more reliable, more obvious, and honestly a little more dummy-proof.
That real-world testing ended up being one of the most important parts of building Vignette because the app isn’t meant to be used while I’m sitting in front of Xcode.
It’s meant to be used while people are actually out making the memories it’s supposed to capture.
Accomplishments that I'm proud of
One of the things I’m most proud of is making no preview actually feel good.
It would be really easy for someone to press the shutter, see nothing happen, and think:
"Did that even take the picture?"
So the camera had to feel instant and trustworthy even though I’m intentionally not showing the result.
I rebuilt the capture flow so the photo gets captured immediately and then the actual upload work happens in the background. Someone can keep hitting the shutter throughout an event without sitting around waiting for every photo to upload.
I'm also really proud of the reveal.
I built an on-device system that looks through the event photos and scores things like sharpness and faces to automatically choose a cover photo for the event.
But I didn't want the host to see that early either.
So even the person who created the event has to wait until it ends to see what Vignette picked. The host gets to be surprised along with everyone else.
I also load-tested galleries with hundreds of real photos, built a disk-backed image cache to keep scrolling smooth, and made saving an entire event to the camera roll resumable. If the app closes or the connection drops halfway through saving everything, you don't have to start all over again.
And probably the biggest accomplishment is just getting the entire thing working end to end.
Authentication, event creation, joining, the camera, photo uploads, galleries, subscriptions, the website, support, privacy, terms, and everything else that comes with actually shipping an app.
I built all of it solo, got it onto TestFlight, and now I've had friends and family actually use it at real events.
Seeing people use something that started as an idea in my head is pretty awesome.
What we learned
The biggest thing I learned while building Vignette is that sometimes the best thing I can do for the app is not add something.
There were plenty of times where I thought:
"Maybe I should add a retake button."
"Maybe I should show a preview."
"Maybe people should be able to organize everything immediately."
But every time I started going down that path, I realized I was slowly turning Vignette back into the normal camera experience I was trying to get away from.
Letting the photo go is what makes the whole thing work.
I also learned plenty of technical lessons the hard way.
At one point I had the photo counter on screen and the actual number of uploaded photos slowly getting out of sync. Something that was supposed to be a cosmetic animation ended up affecting real asynchronous work behind the scenes.
That was a fun one to track down.
I also learned very quickly that "works on my machine" means absolutely nothing once real people have the app.
I had a production configuration issue that completely broke event creation for TestFlight users while everything worked perfectly for me locally.
So now I pay a lot more attention to testing the actual production path instead of assuming that because everything looks good in Xcode, everything is good.
And building this solo made me realize how important having other people actually use your app is.
My friends and family telling me what confused them, what they liked, and what they immediately tried to do shaped Vignette way more than me sitting there testing the same flow another 100 times ever could.
What's next for Vignette – Shared Camera
There’s still a lot I want to do with Vignette.
Some of the next work isn't flashy, but it's important.
I want to move more of the protections that currently exist in the app itself onto the server. Things like photo limits, free-plan event limits, and event-code lookups shouldn't depend entirely on trusting the client.
I also want a proper content-reporting system as more people start sharing galleries, and I want subscription changes to update through real-time webhooks instead of the app having to keep checking for them.
Then there’s the fun stuff.
I want events to eventually feel like actual photo albums instead of everything just dumping into someone's camera roll. I want galleries with thousands of photos to still feel just as fast as galleries with 50.
And eventually, I want Vignette to go beyond iPhone.
Because if you're at a party with 15 people, the whole idea works a lot better when all 15 people can be part of it.
There are a ton of directions I could take Vignette from here, but I don't want to lose the thing that made me want to build it in the first place.
Take the picture. Don't stare at your phone wondering if it was good. Go enjoy the moment.
You'll see the photo later.
Log in or sign up for Devpost to join the conversation.