Book 09 · Software ArchitecturePage 24 of 48

KISS Principle

Keep It Simple, Stupid

In Turkish: KISS İlkesi

Updated September 30, 20262 min read

In short

The KISS principle is a design guideline stating that systems work best when kept as simple as possible, so developers should avoid unnecessary complexity.

What is the KISS principle?

KISS stands for keep it simple, stupid, and it says that most systems work best when they are kept simple rather than made complicated. The phrase is usually credited to aircraft engineer Kelly Johnson, who in the 1960s pushed for jet designs that an average mechanic could repair in the field with basic tools. In software, it means choosing the most straightforward solution that meets the actual requirements.

Applying KISS means writing code that is easy to read rather than clever, using well-known tools and patterns instead of inventing new ones, keeping functions small and focused, and adding as few moving parts to an architecture as possible. A single database and a monolith are often simpler to build and run than a cluster of microservices, message queues, and caches, and they may be all a product needs for years. The simpler design is usually easier to debug, test, change, and explain to a new teammate.

A light switch is a good example of KISS: it has one job, everyone understands it immediately, and it rarely breaks. Compare it with a smart lighting system that needs an app, a hub, and firmware updates just to turn on a lamp. Simple software, like the switch, has fewer places for bugs to hide.

KISS is often confused with YAGNI. YAGNI says not to build features or abstractions until you need them, while KISS says that whatever you do build should be done in the simplest way that works. KISS can also pull against the DRY principle, since removing every bit of duplication sometimes creates abstractions that are harder to understand than the repeated code. And simple isn't the same as simplistic: a design that ignores real requirements, such as error handling or security, is not simple, just incomplete.

Key takeaways

KISS stands for keep it simple, stupid.
Prefer the most straightforward solution that meets the real requirements.
Readable code beats clever code, and fewer moving parts mean fewer failures.
YAGNI is about not building what you don't need; KISS is about building simply.
Simple doesn't mean ignoring requirements like error handling or security.

Example

Overcomplicated versus simple code for the same jobtypescript

// Overcomplicated: a class hierarchy and a registry just to format a price
abstract class Formatter { abstract format(value: number): string; }
class PriceFormatter extends Formatter {
  format(value: number) { return "$" + value.toFixed(2); }
}
const registry = new Map<string, Formatter>([["price", new PriceFormatter()]]);
const label1 = registry.get("price")!.format(9.5);

// Simple: a plain function does the same job
const formatPrice = (value: number) => "$" + value.toFixed(2);
const label2 = formatPrice(9.5); // "$9.50"

Readers ask

What does KISS stand for?

KISS usually stands for keep it simple, stupid. Softer versions such as keep it short and simple are also used, but the meaning is the same: avoid unnecessary complexity.

What is the difference between KISS and YAGNI?

YAGNI tells you not to build something until it is actually needed. KISS tells you to build whatever you do need in the simplest workable way, so the two principles complement each other.

Can code be too simple?

Code can be too simplistic if it ignores real requirements such as validation, error handling, or performance limits. The goal of KISS is to avoid unnecessary complexity, not necessary complexity.