https://themarketplace.guide/minimum-viable-process

The Marketplace Guide  

  *  Introduction
      + Comparisons to other books
  *  Management and Planning
      + Decide if it's a business or a hobby
      + Don't drink the Koolaid
      + Building a marketplace is like training for a marathon
      + Investor value of a marketplace
      + The tech roadmap should follow the business roadmap
      + Bug priorities should relate to your ability to collect money
      + Focus on what if it succeeds
      + Keep track of why decisions were made and features built
      + You're not FAANG so don't hire like FAANG
      + Take hiring seriously
      + Don't create silos
      + What it really means to make data-driven decisions
      + Get good at cohort analysis
      + Removing things is good
      + Be careful with customization for a particular client
      + Convert, grandfather or alienate
  *  Product
      + Deciding what not to build is nearly as important
      + Two approaches to product design
      + Copy blatantly
      + Minimum viable process
      + You might get customers that you weren't planning on
      + Understand your value to your users
      + Don't overreact to weak signals
      + Not everyone's opinion is equal
      + Learn the correct jargon and use it consistently
      + Observed users personas
      + Don't half-ass many things
      + Think about how new things can affect what you already have
      + Consider the complementary interaction
      + Internal product management directly improves your company's
        efficiency
      + Separate the trackers for admins
      + Each job should have a custom dashboard
      + Build a simple flexible dashboard for viewing stats over time
      + Simple user permissions are very useful
      + Use consistent language
  *  Technical
      + Build polite software
      + Take security seriously while you're small and no one is
        likely to exploit you
      + Take testing seriously as you go
      + Take performance seriously while it can't cripple you
      + Use an error tracking tool as early as possible
      + Implement a background task processing structure
      + You can get quite far with a small tech team
      + Write docs religiously or not at all
      + Consider adding these attributes for every new model
      + User interface elements should behave consistently
      + Generate more data than you think you'll need
      + Know when to denormalize columns
      + Maintain a hierarchial structure for settings
      + Have admin editable platform settings from the start
      + Implement an audit log
      + If dealing with money get as close as possible to double
        entry bookkeeping
      + Build and use a robust import feature
      + Build and use a robust export feature
      + Give admins the ability to comment on everything
      + Admins need fudgability
      + Use fewer tools but more completely
      + Be prepared to roll features out in stages
      + If the changes you're working on will require downtime, split
        them into two
      + Use different keys for different parts of the cache
      + Users double click everything
      + Build stats beginning with the rows
      + Create a separate stat model
      + Async selects are easy performance wins
      + Add spellcheck
      + Send alerts when unusual things happen
      + Store all calls from webhooks
  * Cheatsheet
  * Further Reading
  *  Contributing
      + Roadmap
  * Contributors
  * Buy the PDF

Subscribe to updates
---------------------------------------------------------------------
The Marketplace Guide (c) 2021
by Ognjen Regoje
[                    ]

 1. Product
 2. Minimum viable process

Minimum viable process

The software you build is a supporting component for a more efficient
process.

 Your product is more than the tech

New founders often misunderstand product development. They equate the
software they built with the entirety of their product.

But a startup's product is very rarely the technology itself.

It's a software-optimized evolution of an entire existing process.

 Minimum viable processes

The real work of building a startup, particularly a marketplace, lies
in figuring out what to do and in what order, i.e. the process.

That's what Do Things That Don't Scale means - first figure out the
process manually, and only then automate away as much as possible to
scale.

Developing your processes must also follow the familiar principles of
building software.

You need to build your processes.

You need to measure your processes.

You need to learn and iterate on your processes.

You need to release updates to your processes early and often.

The intermediate steps of your processes need to be usable.

 Because that's where most of your value is

Supplybunny's product isn't the platform - it's tail-end sales. The
platform is a tool to accomplish that more effectively and
efficiently than others.

The processes we've developed include supplier onboarding, customer
service, advertising, customer care, etc. Only after we were
reasonably sure of a version of a process did we implement it in
software.

If someone tried to copy Supplybunny, and copied only the software,
they'd end up with just a third of a business.

And that's true not only for most other marketplaces but startups as
well.

Copy blatantly
Previous You might get customers that you weren't planning on
Next

Further reading

  * Do Things That Don't Scale
    An overview of how to develop processes and at which point tech
    should step in


Suggest an improvement to this page (me@ognjen.io)