Reverse Engineering: The Forgotten Craft That Used to Open Every Door

Before open-source dominated, before APIs were documented, before Stack Overflow existed — reverse engineering was how interoperability, drivers, security research, and entire industries got built. A look at a fading discipline, the tools behind it, and why it still matters in 2026.

Pranta Das
Pranta Das
23 min readUpdated Oct 27, 2026
1view

There was a time in software when the answer to "how does this work?" was not a documentation page or a GitHub repo. It was a hex editor, a disassembler, and a long afternoon.

Reverse engineering is the act of taking a finished system — a binary, a protocol, a chip, a savefile, a network message — and recovering enough of its internal structure to either understand it, interoperate with it, or rebuild it. The output is not always code. Sometimes it is a specification document for something that never had one.

For two decades, this was a baseline skill. Drivers got written because someone reverse engineered a Windows driver and figured out what registers the hardware actually expected. Wine exists because thousands of people reverse engineered the Win32 API by feeding it inputs and watching what came out. Samba exists because Andrew Tridgell reverse engineered SMB by capturing traffic between a Windows client and a Windows server and writing down every byte. Compaq became a billion-dollar company by reverse engineering the IBM PC BIOS — legally, through a clean-room process that is now textbook material in IP law courses.

That world has receded. Most software is open source or close enough. Most protocols are documented. Most APIs have OpenAPI specs and an SDK in every major language. The reverse engineering work that used to be daily-driver engineering is now a specialization — malware analysts, vulnerability researchers, game modders, embedded security folks, a handful of compatibility maintainers.

But the craft is not gone. The doors it opened are still open. And in a few specific corners of the industry, it is still the only key.


What Reverse Engineering Actually Is

The clean definition: reverse engineering is recovering the design of a system by analyzing its behavior and artifacts, without access to its original source or specification.

In practice it is a workflow:

  1. Observe. Watch what the system does. Network packets, function calls, file format bytes, register reads, error messages, syscalls.
  2. Hypothesize. Form a theory about the internal structure. "This four-byte header is a length prefix." "This function pointer is loaded from offset 0x40 of the struct." "This handshake byte is a protocol version."
  3. Test. Modify inputs. Watch outputs change. Confirm or revise the theory.
  4. Document. Write down what you have learned in a form that future-you, or other engineers, can use to build something compatible.

The tools are what make this practical. Without them, you are reading raw bytes by hand.


The Tools of the Craft

Every era of reverse engineering had its tooling. Most of it is still around, and some of it still wins.

Hex Editors

The base layer. A hex editor displays a file as bytes, in hexadecimal, with an ASCII column on the right. Tools like HxD, 010 Editor, xxd, and hexdump let you see what is actually in a file, byte for byte.

A useful first move with any unknown binary file:

# Look at the first 128 bytes
xxd -l 128 mystery.bin
00000000: 5041 434b 0100 0000 0a00 0000 4865 6c6c  PACK........Hell
00000010: 6f57 6f72 6c64 0a00 0000 666f 6f62 6172  oWorld....foobar
00000020: 6261 7a00 4032 0000 ...

The ASCII column gives you anchors: PACK is probably a magic number, HelloWorld and foobar and baz are obvious strings. Reading byte-by-byte, you can guess: 4-byte magic, 4-byte version (01 00 00 00 = little-endian 1), 4-byte length (0a 00 00 00 = 10), then a 10-byte string. The structure starts to fall out.

010 Editor goes further — it has binary templates, scripts that parse a file format and present it as a tree. People have written templates for hundreds of formats: PNG, ZIP, ELF, NTFS, save files from specific video games. Loading the right template turns a wall of hex into a labeled, navigable structure.

Disassemblers and Decompilers

When the artifact is an executable rather than a data file, hex is not enough. You need the instruction stream.

objdump is the Unix workhorse:

objdump -d -M intel /bin/ls | head -30

This dumps the disassembly of ls in Intel syntax. You see real x86 instructions: push rbp, mov rax, [rbp-0x8], call 0x4032a0. From there, you can read what the program is doing — if you can read assembly fluently, which is a skill that takes deliberate practice.

Ghidra, released by the NSA in 2019, is the modern free option. It is a full reverse engineering suite: disassembler, decompiler, scripting interface, collaborative project support. The decompiler is the headline feature — it takes assembly and reconstructs C-like pseudo-code:

// Assembly:
//   push rbp
//   mov  rbp, rsp
//   mov  DWORD PTR [rbp-0x4], 0x0
//   jmp  0x4011a0
//   add  DWORD PTR [rbp-0x4], 0x1
//   cmp  DWORD PTR [rbp-0x4], 0x9
//   jle  0x401190
//   pop  rbp
//   ret
 
// Ghidra-style decompilation:
void function(void)
{
    int i;
    for (i = 0; i <= 9; i++) {
        // loop body
    }
    return;
}

The decompiled C is not the original code. Variable names are gone. Comments are gone. Type information is partial. But the structure is recognizable, and a person who reads it carefully can re-derive the algorithm.

IDA Pro is the commercial gold standard, what most professional malware analysts and vulnerability researchers used for two decades before Ghidra existed. It still has the more polished interface for serious work. Binary Ninja is the modern contender — same niche, smaller company, very loyal user base.

radare2 and its frontend Cutter are the open-source CLI-first option, beloved by people who want everything scriptable.

Debuggers

A disassembler tells you what the code is, statically. A debugger tells you what it does, dynamically.

GDB on Linux, lldb on macOS, WinDbg and x64dbg on Windows. You attach to a running process, set breakpoints, inspect registers and memory, step through one instruction at a time.

gdb ./mystery
(gdb) break *0x4011a0
(gdb) run
(gdb) info registers
(gdb) x/16wx $rsp
(gdb) stepi

That session sets a breakpoint at a specific address, runs the binary, dumps the CPU registers when it hits the breakpoint, inspects 16 words on the stack, and steps one instruction forward. With patience, this is how you confirm what a piece of code is actually doing when you cannot fully read it cold.

System Call and Library Call Tracing

A lot of reverse engineering can be done without ever opening a disassembler, by simply watching what a program asks the operating system to do.

strace traces system calls on Linux:

strace -e openat,read,write,connect ./mystery 2>&1 | head -20
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
openat(AT_FDCWD, "config.dat", O_RDONLY) = 4
read(4, "PACK\1\0\0\0\nHelloWorld\0", 64) = 22
connect(5, {sa_family=AF_INET, sin_port=htons(443), sin_addr=inet_addr("203.0.113.42")}, 16) = 0

In seven lines you have learned: the program reads a file called config.dat, it has a PACK magic header, and it then connects to 203.0.113.42:443. You did not disassemble a single instruction.

ltrace does the same for library calls. DTrace on macOS and BSD does both, with a more powerful scripting language. On Windows, Procmon from Sysinternals captures the equivalent file and registry activity at scale.

For network behavior specifically, Wireshark is the universal tool. Capture the traffic, decode the protocol, and you have half the work done before you ever look at the binary.


Doors Reverse Engineering Used to Open

The reason this matters historically is that some of the most consequential pieces of software in the last forty years exist because someone reverse engineered something they did not have permission to read.

Compaq vs IBM: The Clean-Room PC Clone

In 1981, IBM released the IBM Personal Computer. It was built mostly from off-the-shelf parts — an Intel 8088 CPU, a Microsoft operating system — but one component was IBM's: the BIOS, the Basic Input/Output System, the firmware that bridged the operating system and the hardware. IBM held the copyright on the BIOS code and published it openly in their technical reference manual, expecting that copyright alone would prevent competitors from copying it.

Compaq Computer Corporation, founded in 1982, wanted to build IBM-compatible PCs. Compatibility required a BIOS that behaved identically to IBM's. Copying IBM's code directly was not legally viable.

Compaq used a clean-room reverse engineering process. One team of engineers read IBM's published BIOS and wrote a detailed specification of what it did — every function, every register, every memory layout — without writing any code. A second team, who had never seen IBM's code, then implemented a new BIOS strictly from that specification. The chain of custody between the two teams was documented carefully, with sworn affidavits.

The result was a legally clean BIOS that was functionally indistinguishable from IBM's. Compaq shipped its first portable PC in November 1982, sold 53,000 units in its first year, and became the fastest company in history to reach $100M in revenue.

Phoenix Technologies and American Megatrends (AMI) followed the same pattern shortly after, licensing clean-room BIOS implementations to dozens of other PC clone makers. Within five years, IBM had lost effective control of the platform it had invented.

This is the moment "reverse engineering for interoperability" stopped being a curiosity and became an industry-scale economic force. Every PC ever shipped since 1982 traces some lineage back to that legal precedent.

Samba: Talking to Windows on the Network

In 1991, Andrew Tridgell, a PhD student in Australia, wanted to mount a directory from a Unix server on a DOS machine. There was no documented protocol for doing this. The DOS machine spoke SMB (Server Message Block), a proprietary Microsoft protocol, and there were no Unix implementations.

Tridgell ran a packet sniffer on the network, captured the SMB traffic between two DOS machines, and started decoding it byte by byte. He published his work as a small project called nbserver, which a year later was renamed Samba.

Samba grew over the next three decades into the canonical open-source SMB implementation. Every Linux file server that shows up on a Windows network, every NAS appliance that supports Windows shares, every macOS Finder that can browse \\server\share — all of it is downstream of Tridgell's packet captures.

Microsoft did not document SMB officially until 2008, under pressure from a European Union antitrust ruling. By that point, Samba had been working for sixteen years on reverse-engineered knowledge.

Wine: Running Windows Binaries on Linux

The Wine project was launched in 1993 with a goal that sounded slightly insane: implement the entire Win32 API on Linux, so that Windows applications could run unmodified.

Win32 is enormous. Thousands of functions, dozens of subsystems, an entire object model (COM), a graphics stack (GDI), a media framework, a registry, a window manager. None of it was documented at the level of detail needed to reproduce its behavior exactly. Microsoft applications relied on undocumented behavior of the API, edge cases in error handling, and quirks in memory layout that no specification would ever describe.

Wine developers spent thirty years and counting reverse engineering this. The standard workflow: run a Windows application in Wine, observe what API call it crashes on, write tests that compare Windows's actual behavior to Wine's current behavior, fix Wine until they match, repeat for the next ten thousand functions.

By 2026, Wine runs an enormous fraction of Windows software well enough that Proton (Valve's Wine fork) makes the Steam Deck a viable PC gaming platform on Linux. Microsoft's own Windows Subsystem for Linux works in roughly the opposite direction, but the cultural and technical foundation that "you can run code from one OS on another" became normal because Wine spent three decades reverse engineering Win32 by hand.

Linux Drivers for Hardware Nobody Documented

For most of the 1990s and 2000s, hardware vendors did not write Linux drivers. They wrote Windows drivers, shipped them on a CD with the hardware, and considered Linux too small a market to justify the engineering.

Linux developers — often the single user who happened to own the hardware — would reverse engineer the Windows driver to figure out what the device needed. They would dump the driver binary, look at the I/O it issued to the PCI device, capture the bus traffic on a logic analyzer, and slowly reconstruct the device's command interface.

The Linux wireless networking driver landscape in 2005-2010 was almost entirely a reverse engineering effort. Atheros, Broadcom, Ralink, Realtek — most chipsets ran in Linux because someone, somewhere, took apart the Windows driver and wrote down the magic registers.

This was unglamorous, often anonymous work. The author of a working driver typically did not get rich, did not get famous, and frequently did not even know what specific quirk of the hardware they had figured out. The output was a kernel module, merged upstream, and that was the entire reward.

OpenOffice and File Format Recovery

When Sun Microsystems built OpenOffice to compete with Microsoft Office, they had to read and write .doc, .xls, and .ppt files. Microsoft's binary office formats were closed, undocumented at any useful level, and full of decades of accreted legacy decisions — handling for character encodings from the 1980s, formula calculation quirks, embedded compound document streams, OLE objects.

Reverse engineering the Microsoft Office binary formats was a multi-year, multi-developer project. People wrote down what each byte of a .doc file appeared to mean, tested theories by saving documents in Word with controlled inputs, and gradually built up enough of a specification to read and write the format reliably.

This work is now invisible. Microsoft published the format specifications under pressure in 2008. OOXML and ODF are open and well-documented. But the years between 2000 and 2008, when OpenOffice (and later LibreOffice) became a real alternative for office work, were powered by binary archaeology.


A Worked Example: Reverse Engineering a Tiny Binary File Format

The fastest way to feel what this work is like is to do a miniature version of it. Imagine you have a file format from an application you don't have source code for, and you need to parse it.

Let's pretend mystery.bin looks like this in hex:

00000000: 4d59 4442 0200 0000 0300 0000             MYDB........
00000010: 0500 0000 416c 6963 6500 0000 1e00 0000   ....Alice......
00000020: 0500 0000 426f 6262 6f00 0000 2400 0000   ....Bobbo...$...
00000030: 0700 0000 4361 726f 6c79 6e00 1900 0000   ....Carolyn....

Walking it:

  • Bytes 00-03: 4d 59 44 42 = "MYDB". Probably a magic number.
  • Bytes 04-07: 02 00 00 00 = little-endian 32-bit integer 2. A version, likely.
  • Bytes 08-0b: 03 00 00 00 = little-endian 32-bit integer 3. A count, maybe of records.

Now the records start at offset 0x0c. Trying a structure of "length-prefixed name + age":

  • Bytes 0c-0f: 05 00 00 00 = 5. A length.
  • Bytes 10-14: 41 6c 69 63 65 = "Alice". Five bytes, matching the length.
  • Bytes 15-17: 00 00 00. Padding to align to 4-byte boundary?
  • Bytes 18-1b: 1e 00 00 00 = 30. Probably Alice's age.

Pattern check on the next record:

  • 05 00 00 00 = 5
  • 42 6f 62 62 6f = "Bobbo", 5 bytes
  • 00 00 00 padding
  • 24 00 00 00 = 36, age

And the next:

  • 07 00 00 00 = 7
  • 43 61 72 6f 6c 79 6e = "Carolyn", 7 bytes
  • 00 padding (only 1 byte needed for 4-byte alignment)
  • 19 00 00 00 = 25, age

Three records, exactly matching the count in the header. The format is:

struct file {
  char     magic[4];        // "MYDB"
  uint32_t version;         // little-endian
  uint32_t record_count;
  record   records[record_count];
};
 
struct record {
  uint32_t name_length;
  char     name[name_length];
  char     padding[align_to_4(name_length) - name_length];
  uint32_t age;
};

A parser in any language:

const fs = require('fs');
 
function parseMyDB(filePath) {
  const buf = fs.readFileSync(filePath);
 
  const magic = buf.toString('ascii', 0, 4);
  if (magic !== 'MYDB') throw new Error(`Bad magic: ${magic}`);
 
  const version = buf.readUInt32LE(4);
  const count = buf.readUInt32LE(8);
 
  const records = [];
  let offset = 12;
 
  for (let i = 0; i < count; i++) {
    const nameLen = buf.readUInt32LE(offset);
    offset += 4;
    const name = buf.toString('utf8', offset, offset + nameLen);
    offset += nameLen;
    // Align to 4-byte boundary
    offset += (4 - (nameLen % 4)) % 4;
    const age = buf.readUInt32LE(offset);
    offset += 4;
    records.push({ name, age });
  }
 
  return { version, records };
}
 
console.log(parseMyDB('mystery.bin'));
// { version: 2, records: [
//   { name: 'Alice', age: 30 },
//   { name: 'Bobbo', age: 36 },
//   { name: 'Carolyn', age: 25 },
// ]}

That is reverse engineering in miniature. You started with bytes, formed a hypothesis from regularities, tested it against the data, and ended with a parser. The technique scales — the difference between this exercise and reverse engineering, say, the .doc format is volume, complexity, and the patience to do this same thing ten thousand times in a row.


A Network Protocol Example

Binary file formats are one half of reverse engineering. Network protocols are the other.

Suppose you are trying to integrate with a vendor's IoT device that uses a custom TCP protocol over port 4567, with no documentation. The minimal workflow:

# Capture traffic between the device and the official mobile app
sudo tcpdump -i any -w device.pcap port 4567

Open device.pcap in Wireshark. Click through packets. Watch what bytes go in each direction during the app's "turn the light on" action.

You might see this sequence:

> 02 00 00 0A 01 03 00 00 00 01 D8
< 02 00 00 06 81 03 00 00 00 01

First packet, client to device: 11 bytes. Second packet, device to client: 10 bytes.

Hypothesis:

  • Byte 0: 02 = sync byte, probably a fixed protocol marker.
  • Bytes 1-2: 00 00 = some kind of session ID, zero in unauthenticated mode.
  • Byte 3: 0A = 10 = length of the rest of the message? Counting the rest: 7 bytes. Off by a few. Try "length including the length byte itself": 10 matches the full message length minus the sync byte. Match.
  • Byte 4: 01 = command ID. "Set light state."
  • Bytes 5-8: 03 00 00 00 = little-endian 3. Light index?
  • Byte 9: 01 = on (vs. 00 for off?)
  • Byte 10: D8 = checksum? Possibly a CRC-8 over the preceding bytes.

Run the test: send the same packet with 01 replaced by 00. If the light turns off, hypothesis confirmed. Send the packet with 03 00 00 00 replaced by 04 00 00 00. If a different light responds, that confirms the light index theory.

Each test refines the picture. After enough rounds, you have a full protocol specification — written down by you, derived from observation alone, without ever reading the device's firmware.

This is exactly the workflow that produced Samba, drivers for thousands of WiFi chipsets, the Z-Wave protocol stack in OpenZWave, the unofficial Sonos control libraries, and most of the home automation integrations that Home Assistant ships with.


Why the Craft Receded

Several things happened in parallel that made reverse engineering less central to everyday software work.

Open source ate the world. When the operating system, the compiler, the database, the web server, the application framework, and most of the libraries you depend on are open source, "I'd like to know how this works" is answered by reading source code, not by disassembling a binary. The reverse engineering effort that used to go into understanding libc is now a fifteen-minute scroll through glibc on GitHub.

APIs became documented by default. Every modern web service publishes an OpenAPI spec, a GraphQL schema, an SDK, or at minimum a docs site. The era of "the only way to learn this third-party API is to watch what the partner's official client does" has narrowed to a few legacy enterprise integrations and some intentionally obscure proprietary systems.

Browser developer tools made web reverse engineering trivial. The Network panel of Chrome DevTools is a Wireshark for HTTP, with built-in JSON pretty-printing, request replay, and authentication header inspection. Reverse engineering a web app's "private" API now takes minutes, not afternoons. This shifted the discipline from "specialized skill" to "thing every web developer can do casually."

The legal climate became more cautious. The DMCA (1998) in the United States and Article 6 of the EU Copyright Directive (2001) both criminalize circumventing technical protection measures, with carve-outs for interoperability that are narrower than what a clean-room engineer could do in 1982. Reverse engineering still has legal cover for compatibility purposes, but the chilling effect is real, and companies are more reluctant to fund reverse engineering work than they once were.

Software stopped being shipped as opaque binaries. Mobile apps, web apps, server-side software — most of what users interact with is either delivered as JavaScript (readable in DevTools), runs on a server you can't reach at all, or sits behind a documented API. The "I want to integrate with this Windows desktop application" problem is rarer than it was in 1995.

The work that used to take hundreds of hours of disassembly is now a grep away.


Where Reverse Engineering Still Matters in 2026

For all the receding, there are corners of the industry where reverse engineering is still the only path.

Malware analysis. Every malware sample is an opaque binary. Every incident response engagement at a company that got breached involves reverse engineers picking apart the attacker's tooling to understand what was stolen and how the intrusion happened. Ghidra, IDA Pro, and a fleet of automated analysis sandboxes are working twenty-four hours a day in companies like Mandiant, CrowdStrike, and Microsoft's MSTIC.

Vulnerability research. Finding a 0-day exploit in iOS, in the Chrome renderer, in an enterprise VPN appliance, in a car's CAN bus stack — all of this is reverse engineering. The person on stage at DEF CON presenting a Pwn2Own exploit spent six months in IDA Pro understanding code that was never meant to be understood by an outsider.

IoT and embedded security. Smart home devices, medical devices, industrial control systems, automotive ECUs. Most of these run firmware that is not open source, was not written with security as a primary concern, and is deployed by the millions. The community that researches their safety properties is doing reverse engineering, almost exclusively.

Game modding and preservation. Reverse engineering save file formats, network protocols, and game engines is a huge part of how communities keep older games alive. Decompilation projects for classic Nintendo and Sega games — decomp projects that produce buildable C source from ROMs — are an entire subculture, with technical work as serious as anything in industry.

Legacy compatibility. When a company depends on a piece of software whose vendor went out of business twenty years ago, and the data is in a proprietary format, reverse engineering is the only way out. The Computer History Museum, the Internet Archive, and various national libraries fund a steady amount of this kind of work to preserve formats that would otherwise be unreadable in fifty years.

Driver development for unsupported hardware. Linux and BSD developers still reverse engineer Windows drivers for hardware that vendors refuse to support. Less common than it was, but not extinct.


A Modern Engineer's Light Toolkit for Reverse Engineering

Most software engineers will never sit in IDA Pro for a living. But the lightweight version of these skills is still useful, and easier to pick up than it looks.

A reasonable starting kit:

  • xxd / hexdump for looking at any binary file you don't recognize.
  • file to make a first guess at what a file is (ELF 64-bit LSB executable, PNG image, etc.).
  • strings to dump printable ASCII out of a binary — often reveals embedded URLs, error messages, format strings.
  • strace / ltrace / dtrace to watch what a process is doing without disassembling it.
  • Wireshark for any unknown network behavior.
  • Browser DevTools Network panel for any web service.
  • Ghidra for the rare moment you actually need to look at machine code.

A typical "I need to figure out what this thing is doing" investigation in 2026 looks like:

file unknown_program
# unknown_program: ELF 64-bit LSB executable, x86-64
 
strings unknown_program | grep -iE 'http|api|version|key'
# Surprisingly often, this is enough.
 
strace -f -e openat,connect,read,write ./unknown_program 2>&1 | less
# What files does it open? What does it connect to?
 
# If still stuck:
ghidra
# Open the binary, look at the function list, search for any strings
# you found earlier, find the functions that reference them.

You will get an enormous distance with strings and strace alone. Most curiosity-level reverse engineering never gets past that point.


Closing

Reverse engineering is the original engineering. Long before software development had textbooks, package managers, language reference manuals, and "well-documented" as a standard product quality, the way you learned how a system worked was to take it apart.

The PC industry exists in its current form because a few engineers at Compaq decided to reverse engineer an IBM BIOS the legally rigorous way. Linux talks to Windows file shares because of one researcher's packet captures in 1991. Steam Deck plays AAA Windows games on Linux because thirty years of volunteer reverse engineers learned what kernel32.dll does well enough to clone it. The home automation in millions of houses works because someone, somewhere, pointed Wireshark at a Z-Wave controller and wrote down what they saw.

This work has gotten less common because the world it operated in changed. Documentation is better. Source is more available. Standards bodies do work that used to require black-box analysis. That is a good outcome.

But the craft is still load-bearing under specific parts of the modern stack, and learning even a sliver of it changes how you think about software. Once you have spent an afternoon parsing an undocumented binary format by hand, every documented format you see afterward looks slightly different — like a long letter from someone who decided to be kind to you, instead of a sealed box you have to pry open.

It's worth being a little reverent about the people who pried open the boxes that came before. A lot of the doors that are now permanently open were unlocked by them, one byte at a time.


The first reverse engineering I ever did was looking at a savefile from a game I loved, in a hex editor, trying to figure out how to give my character more gold. I succeeded after a weekend. I learned more about how computers actually store information from that exercise than from a year of school. The craft is still teaching that lesson to anyone willing to open a hex editor and ask, "what is this, really?"

Share this article
Pranta Das
Pranta Das
Backend Developer & Team Lead · Dhaka, Bangladesh 🇧🇩

Backend Developer & Team Lead building scalable systems and sharing engineering insights from Dhaka, Bangladesh.

Comments

No comments yet — be the first!

Related Articles

When Everything Goes Wrong: Why Great Teams Solve Problems Instead of Looking for Someone to Blame

Missed deadlines, production outages, failed deployments — every software team faces these. What separates great engineering cultures from dysfunctional ones is not the absence of failure, but what happens in the minutes and hours immediately after.

Jun 8, 202613 min read

Before Vercel and Render: How We Used to Host Frontends and Backends

Vercel didn't invent shipping a website, and Render didn't invent running a Node.js server. They abstracted years of patterns developers had been hand-rolling on bare VPS boxes. Here is what hosting actually looked like before the dashboard.

Jun 7, 202617 min read

Startup Engineering Is Not Netflix Engineering

Many engineers enter startups with the mental model of Netflix, Google, or Stripe: dedicated QA teams, seasoned product managers, enterprise tooling, and months of runway for research. The startup has three developers, one founder, a few paying customers, and a deadline that passed two weeks ago. The expectations cannot be the same — and the gap between them is where many careers stall.

Jun 3, 202618 min read