RideCoop

RideCoop is a driver-owned rideshare coop, starting in Philadelphia. Riders should pay less. Drivers should keep about 90% of every fare.

It is the first operating subsidiary under Sherwood. One driver, one vote. Cash now, equity over time.

The idea

The whole thing starts with the $10 ride. Not a pitch-deck ride. An ordinary short ride across town.

In my working model, $8 goes to the driver. $1 runs the company. $1 goes into the driver’s own capital account. Uber keeps around half. That is the broken part.

The way I said it in June:

“always take one dollar every ride… whether it’s a twenty-five dollar ride, ten dollar ride, hundred dollar ride. And drivers get ownership in the coop, the umbrella conglomerate… they get the conglomerate going, form other companies under it.”

That last part matters. RideCoop is not meant to be a nicer contractor app with a friendlier logo. The driver is not just earning on today’s ride. The driver is helping build the parent cooperative that can form the next company after rideshare.

The point is to stop treating drivers like a temporary input. If you do the work, you should own the thing. If you help prove the model, you should own part of the model after it moves into groceries, delivery, care work, or whatever comes next. A driver’s phone already runs the whole job. The only thing the platform actually owns is the network and the paperwork, and both of those can belong to the people doing the driving.

What exists today

• A full-featured app exists in the repo.
• Riders can request a ride and see fare estimates before confirming.
• The map uses open maps, not a locked commercial ride-hailing world.
• Live driver tracking is wired into the rider flow.
• Drivers have a dashboard for rides, earnings, and status.
• Instant payouts are designed around Stripe Connect.
• The app includes governance voting, because ownership without voting is decoration.
• The pricing model includes local rides and long-haul pricing.
• The prototype includes the capital-account idea: part of the fare becomes driver ownership, not just company revenue.
• There is now a guided browser demo built into the app, including the demo-mode sign-in path.
• The public app flow shows a rider request, a driver accepting with the payout visible, live ride tracking, and the final fare split.
• The web app and the native mobile app now share the same core ride, driver, coop, and wallet work instead of the phone being a marketing afterthought.
• The transparency page carries the coop-accountability details, and the marketing pages now hold up on both desktop and phone-sized screens.
• The vehicle markers were replaced with a consistent set of real-car illustrations, including the moving car in ride replay.
• RideCoop is linked back to Sherwood because the ownership story lives at the umbrella level.

The prototype proves the mechanics I needed it to prove. A rider can ask for a ride. A driver can accept work. Money can be split in a way that treats the driver as a worker-owner instead of a disposable contractor.

What it isn’t yet

RideCoop is not on the road.

There are no active drivers. There is no insurance wrapper. There is no approved legal structure that drivers have joined. There is no dispatch operation. There is no live phone support, no safety process, no airport playbook, no background-check pipeline, no vehicle inspection workflow, and no customer service schedule.

The app is a serious prototype, not a transportation company. A ride-hailing company becomes real in the boring parts: insurance, compliance, training, trust, refunds, edge cases, bad weather, airport rules, driver conflict, rider conflict, taxes, and keeping the lights on when nobody feels like being heroic anymore.

I am naming that plainly because pretending otherwise is how platform companies get people hurt.

Where it’s going

The plan is Philadelphia first. I live here. I understand the shape of the city better than I understand any abstraction called “urban mobility.”

My working number is the same one I keep coming back to: on a $10 ride, $8 to the driver, $1 to run the company, $1 to the driver’s capital account. The percentages can move when real insurance numbers show up. The principle cannot. The worker should keep the money, and the worker should own the machine.

The next step is not more code. It is a founding circle: Philly drivers who want to own the thing they work for, plus coop, legal, and insurance people who can keep me from making naive mistakes.

If RideCoop works, it becomes the first proof that Sherwood can build companies whose workers own the roof, not just the room they happen to be standing in.

And when it works, the recipe goes out free: the fare math, the legal pattern, the software. Drivers in other cities should not have to rediscover any of this. I’m writing it up as the model proves itself, and it lands on the Pantry.