System design: Building a Vending Machine in Go

Living in Tokyo, Japan, I’m surrounded by vending machines offering everything from hot coffee to cold drinks and snacks.Inspired by these iconic machines, I trued to build a vending machine system design in Go. It's a cool example of using the State pattern, and I'll break down why it's super useful for this kind of project.

Why a Vending Machine?

Think about a real vending machine - it's actually pretty complex! It needs to:

• Keep track of products and their quantities
• Handle money
• Make sure you've put in enough cash
• Give you your snack
• Return your change

Plus, it needs to do all this without getting confused about what state it's in.

---

The Basic Building Blocks

First up, I needed some basic structures to work with:

Products and Inventory
Each product has an ID, name, price, and quantity. Pretty straightforward stuff:

type Product struct {
    ID       int
    Name     string
    Price    float64
    Quantity int
}

The inventory keeps track of all products using a map. It can:

• Add new products
• Remove products
• Handle transactions (like when someone buys something)
• Check if products are available

The State Pattern: Why It's Awesome Here

Here's where it gets interesting. A vending machine can be in different states:

• Waiting for money
• Money inserted
• Product selected
• Dispensing product

Each state needs to handle user actions differently. Like, you can't select a product before putting in money, right?
I used three main states:

1. MoneyInsertedState
2. ProductSelectedState
3. ProductDispensedState

Each state implements this interface:

type State interface {
    InsertMoney(amount float64)
    SelectProduct(product *Product)
    ReturnChange()
    DispenseProduct()
}

How It All Works Together

Let's say you want to buy a Coke:

First, you insert $2.00

• The machine is in MoneyInsertedState
• It records your money
• Switches to ProductSelectedState

You select Coke ($1.50)

• Machine checks if it has Coke in stock
• Verifies you put in enough money
• Moves to ProductDispensedState

Machine dispenses your Coke

• Updates inventory
• Returns your $0.50 change
• Goes back to MoneyInsertedState

---

Cool Features I Added

• Stock Management: Each product starts with 3 units. When something's sold out, it's automatically removed from available options.
• Smart Change Handling: The machine always calculates and returns the correct change after a purchase.
• Error Prevention: The state pattern helps prevent weird situations like, trying to buy stuff without enough money, selecting products that are out of stock, inserting money while something's being dispensed.

What I Learned

Building this taught me a few things:

• The State pattern is perfect for machines with clear, distinct states
• Go's interfaces make implementing state patterns really clean
• Proper error handling is super important for real-world applications

What's Next?

There's always room for improvement! Some ideas:

• Add support for card payments
• Implement a display system
• Add temperature monitoring for drinks
• Create an admin interface for restocking

---

The full code is more detailed than what I showed here, but these are the main pieces that make it work. Feel free to check the full implementation in the following repo:

thesaltree / low-level-design-golang

Low level system design solutions in Golang

Low-Level System Design in Go

Welcome to the Low-Level System Design in Go repository! This repository contains various low-level system design problems and their solutions implemented in Go. The primary aim is to demonstrate the design and architecture of systems through practical examples.

Table of Contents

• Overview
• Parking Lot System
• Elevator System
• Library Management System
• Vending Machine System
• Social Media Platform

Overview

Low-level system design involves understanding the core concepts of system architecture and designing scalable, maintainable, and efficient systems. This repository will try to cover solutions of various problems and scenarios using Go.

Parking Lot System

The first project in this repository is a Parking Lot System. This system simulates a parking lot where vehicles can be parked and unparked. It demonstrates:

• Singleton design pattern for managing the parking lot instance.
• Handling different types of vehicles (e.g., cars, trucks).
• Parking space management across multiple floors.
• Payment processing for…

View on GitHub

Comments

[sinni800]

I would add that you should never save money quantities as a float, even if you use 64 bits of precision. Just use an integer and move the comma when displaying. For dollars, just represent cents.

Also you will need a transaction log of sorts... Very important for the bureaucracy afterwards.

Then... When it said low level design I thought you'd be designing all the possible failure modes a physical machine could have as well. That's I think another important idea. Otherwise it really is high level design and quite a bit away from designing the actual software for a vending machine.

It's a good learning exercise though to think about a state machine line that. I expected dark magic of low level systems programming for a second film the title, haha

[Saloni Agarwal]

Thanks for the feedback! Great point on using integers for money—that's a solid way to avoid float issues. I’ll definitely add that, along with a transaction log to keep track of purchases.

And yeah, I get what you’re saying about “low-level.” I focused more on the usage of State pattern, but adding failure modes and other aspects could make it feel more realistic. Appreciate the ideas—might dive deeper into those next!