Leanpub Header

Skip to main content

The Software Field Guide

The Software Field Guide
This book is 70% completeLast updated on 2026-11-19

Strategy does not ship software. This is one level down: 54 field chapters of working material for the people who design, build, review, generate, test, deploy, and operate the real systems.

Minimum price

Free!

$29.00

You pay

Author earns

$

Also available for 2 book credits with a Reader Membership

PDF
EPUB
About

About

About the Book

The Software Field Guide takes the engineering level that strategy books skip: the discipline that stands between a decision made in an architecture review and a system that works in production. Written for software engineers, tech leads, platform and DevOps engineers, and hands-on architects, its 54 self-contained chapters each state a problem, show the reasoning, and end in something you can use — an evaluation to test against your own codebase, a pattern with concrete thresholds, a contract, or a worked example. Six parts group the chapters as reading trails, never prerequisites: Architecting the Runtime, Languages and Agents, Operating Distributed Systems, Owning the Data, Operating and Improving, and Composable Infrastructure Components. All diagrams ship in editable drawio format.

Author

About the Author

Agile Enterprise Media ApS

Lars Shakya Buch-Jepsen is a coding software, ai and data architect with more than 20 years of hands-on experience across enterprise architecture, data warehousing, integration, and cloud engineering. He has served as CTO, enterprise advisor to CTO offices, and today leads the technical branch of DevX, AI & Data at Aeven, helping regulated industries adopt AI, data services, and DevOps under strict compliance regimes.

The FOCUS Methodology was born from years of friction: Enterprise Architecture that was outdated the moment it was written, governance that stopped delivery instead of enabling it, or no architecture function at all — leaving teams to improvise. This book series is the how-to playbook he wished existed: the frameworks, worksheets, and decision workflows to run technology effectively in the age of GenAI, without failing compliance.

Contents

Table of Contents

Foreword

Architecting the Runtime

Working Effectively with Modular Monoliths

  1. The problem this chapter solves
  2. What you need
  3. The architecture
  4. The plugin lifecycle, step by step
  5. Event-driven communication between plugins
  6. Dynamic navigation from plugin metadata
  7. Operational baseline
  8. When to reach for this pattern
  9. Open risks (stated plainly)
  10. Evaluation status
  11. Where to look

Reversible Plugin Execution — Keeping the Microservices Option Open

  1. The problem this chapter solves
  2. The library architecture
  3. Plugin identity as value types, not strings
  4. Isolated loading: the collectible AssemblyLoadContext
  5. Typed execution
  6. The security validation pipeline
  7. Testing discipline: what 48 tests actually prove
  8. Hybrid execution: v2.1.0 and the containerized mode
  9. The design trade, stated plainly
  10. When to reach for this pattern
  11. Open risks (stated plainly)
  12. Evaluation status
  13. Where to look

Managing Extension Points Without Over-Engineering

  1. The problem
  2. What you need
  3. The decision: what earns a seam
  4. A working taxonomy
  5. Designing the contract
  6. Team cooperation mechanics
  7. The complexity ledger and the collapse discipline
  8. Safety at the boundary
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

Bounded Contexts as Independently Versioned Packages

  1. The problem this chapter solves
  2. The thesis
  3. Where the idea comes from
  4. The system (shipped)
  5. The DDD reading (design analysis)
  6. Limiting required domain knowledge
  7. When to reach for this pattern
  8. Open risks (stated plainly)
  9. Evaluation status
  10. Conclusion
  11. Where to look

Engineering Multitenant Isolation

  1. The problem this chapter solves
  2. What you need
  3. Layer 1 — Application-scoped tenancy
  4. Layer 2 — Database-enforced isolation (row-level security)
  5. Layer 3 — Tenant-bound cryptography (envelope encryption)
  6. Resolving and provisioning tenants
  7. When to reach for this pattern
  8. Open risks (stated plainly)
  9. Evaluation status
  10. Where to look

Reliable Event-Driven Integration Across Boundaries

  1. The problem this chapter solves
  2. What you need
  3. The transactional outbox
  4. The idempotent consumer
  5. The dead-letter route — failure as a designed path
  6. Event schemas that evolve
  7. Backpressure and queue depth as operational signals
  8. When to reach for this pattern
  9. Open risks (stated plainly)
  10. Evaluation status
  11. Where to look

Strangler-Fig Migration and Retirement Engineering

  1. The problem this chapter solves
  2. What you need
  3. Routing seams and anti-corruption layers
  4. Dual-running with verification
  5. Retirement engineering: the exit door designed on the way in
  6. When the strangler stops being worth it
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

Languages and Agents

Building and Working with Domain-Specific Languages

  1. The problem this chapter solves
  2. The workbench architecture
  3. Defining a language: the grammar file
  4. Grammar inheritance: language families and version management
  5. Embedded languages: context switching
  6. Grammars as data: the grammar library
  7. The case studies, labeled honestly
  8. Limitations (stated in the source, kept here)
  9. When to reach for this pattern
  10. Evaluation status
  11. License note — read before adopting
  12. Where to look

SpecTree — Method for Improved Human–Code-Agent Handovers

  1. 1. Why SpecTree exists
  2. 2. Core concepts (carried forward from SDD)
  3. 3. The handover model
  4. 4. Trigger rules — the operational contract
  5. 5. The pull-request lifecycle
  6. 6. Environments: where humans meet the tree
  7. 7. Bootstrapping the tree from existing code (H5)
  8. 8. Guardrails and risks
  9. 9. Adoption path
  10. 10. Evaluation status
  11. Appendix — lineage from the earlier documents
  12. Works consulted — the intent-centric review literature

The Agentic Kill Switch and LLM Firewall at Runtime

  1. The problem this chapter solves
  2. What you need
  3. The LLM firewall: default-deny at the tool boundary
  4. Kill-switch mechanics: circuit breakers and staged permission rollback
  5. Re-entry gates and the signed restoration record
  6. When to reach for this pattern
  7. Open risks
  8. Evaluation status
  9. Where to look

Engineering Self-Evolving Code with Security Guardrails

  1. The problem this chapter solves
  2. What you need
  3. The evolution loop: chromosomes of source, informed mutation, computed fitness
  4. The security guardrails: AST facts, Rego policies, unload, and budgets
  5. Adversarial review and local-first model routing
  6. When to reach for this pattern
  7. Open risks
  8. Evaluation status
  9. Where to look

Specification-Driven Test Generation and Predictive Regression

  1. The problem this chapter solves
  2. What you need
  3. The pipeline: contracts in, test proposals out
  4. Event-driven execution and failure clustering
  5. Predictive regression: change impact, drift triage, and fuzzing
  6. Coverage as a risk signal — and the builds that catch rot
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

Collaborative Domain Discovery on a Shared Canvas

  1. The problem
  2. What you need
  3. A typed canvas, not a digital wall
  4. Permissioned collaboration: who may move what
  5. From storm to specification
  6. When to reach for this pattern
  7. Open risks
  8. Evaluation status
  9. Where to look

Citizen Development on Specification Rails

  1. The problem
  2. What you need
  3. The specification rail: a virtual structure over any codebase
  4. The draft-PR pipeline: from edit to reviewed change
  5. Governance as code — and the honesty ledger
  6. When to reach for this pattern
  7. Open risks
  8. Evaluation status
  9. Where to look

Grounding GenAI in Organizational Knowledge

  1. The problem
  2. What you need
  3. The grounding stack
  4. From vector search to knowledge graphs
  5. Session context: the other half of grounding
  6. When to reach for this pattern
  7. Open risks
  8. Evaluation status
  9. Where to look

Bounded Agent Execution Through a Micro-Action Vocabulary

  1. The problem
  2. What you need
  3. The action contract: anatomy of a micro-action
  4. From intent to invocation
  5. Execution and isolation
  6. Trusting work that leaves the box
  7. The vocabulary as guardrail
  8. When to reach for this pattern
  9. Open risks
  10. Evaluation status
  11. Where to look

LLM and Agent Evaluation Harnesses

  1. The problem
  2. What you need
  3. What an eval harness actually is
  4. Retrieval eval: the grounding chapter’s required harness, built
  5. Generation eval: faithfulness, refusal correctness, and the benchmark trap
  6. Agent and task eval: from structural fitness to semantic outcomes
  7. Eval as CI: gating the things that change
  8. Honest measurement discipline
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

Old Bias, New Expression — Machine Bias in the GenAI Era

  1. The problem
  2. A way of seeing: the old taxonomy, re-expressed
  3. The corpus you choose is the bias you ship
  4. Bias as an eval dimension, not a vibe
  5. Agents close the loop at machine speed
  6. When to reach for this pattern
  7. Open risks
  8. Evaluation status
  9. Where to look
  10. Works cited

Engineering the Human Decision — UX and Psychology for Real Human-in-the-Loop GenAI

  1. The problem
  2. The psychology that defeats naive loops
  3. The decision inventory: what is the human actually deciding?
  4. UX mechanics that manufacture real decisions
  5. The worked example: the book’s own spine
  6. When to reach for this pattern
  7. Open risks
  8. Evaluation status
  9. Where to look
  10. Works cited

Deterministic Chains — An Operations Agent That Earns Production Access

  1. Companion diagrams (editable drawio)
  2. What you need
  3. 1. The position: non-determinism is an operational property
  4. 2. Chains as records, test as the only first environment
  5. 3. Promotion is earned, then approved
  6. 4. Irreversible is never automated
  7. 5. The operator is small, dumb, and auditable
  8. 6. Takeover, not reduction
  9. 7. Anti-patterns, honestly
  10. 8. When to reach for this pattern
  11. 9. Open risks
  12. 10. Checklist
  13. 11. Evaluation status
  14. 12. Works cited

Operating Distributed Systems

Separating Network Responsibilities in Distributed Systems

  1. Companion diagrams (editable drawio)
  2. 1. The first distinction: which plane is executing right now?
  3. 2. The second distinction: which direction may the traffic flow?
  4. 3. The third distinction: what happens over time — maintenance without severance
  5. 4. The fourth distinction: how far does administrative reach extend?
  6. 5. The fifth distinction: how deep is the enforcement point?
  7. 6. Using the lens honestly: where the naive reading goes wrong
  8. 7. Working guidance: five questions, five rules
  9. Works cited

Thinking Inside the Network — Microsegmentation as Code

  1. Companion diagrams (editable drawio)
  2. 1. What microsegmentation actually is — and what it is not
  3. 2. The core principle: policy follows identity, not topology
  4. 3. The five enforcement layers
  5. 4. Git tooling in layers
  6. 5. The toolchain: who owns what
  7. 6. eBPF: enforcement inside the network
  8. 7. Day 1: admitting a new segment
  9. 8. Day 2: operating segments with IaC
  10. 9. One methodology, three renders: Windows, Linux, Kubernetes
  11. 10. Synthesis and actionable guidance
  12. Evaluation status
  13. Works cited

Segmenting the Estate — Enclaves and Zero Trust at Scale

  1. 1. The estate problem: when the network diagram stops fitting on one page
  2. 2. The vocabulary: estate, enclave, seam, ring
  3. 3. Rings, not walls: defense in depth that zero trust can live with
  4. 4. The model reused: responsibility planes at estate scale
  5. 5. Cross-cloud enclaves: one estate policy, many fabrics
  6. 6. Cross-company enclaves: partners, vendors, and the seam you do not own
  7. 7. Local and OT systems: the estate’s oldest enclaves
  8. 8. Seams are the product
  9. 9. The estate in Git
  10. 10. Day 2 at estate scale
  11. 11. One methodology, many renders
  12. 12. Synthesis
  13. Evaluation status
  14. Works cited

Secure Developer Ingress Through a Hardened Multitenant Reverse Proxy

  1. The problem this chapter solves
  2. What you need
  3. The platform: one hardened ingress, many named users
  4. Authorization as the seam: per-user allowed-domain patterns
  5. Operations: renditions, SLOs, and the honest limits
  6. When to reach for this pattern
  7. Open risks
  8. Evaluation status
  9. Where to look

Application Identity, Authentication, and Secrets

  1. The problem
  2. What you need
  3. Authentication engineering
  4. Authorization as data
  5. Service identity and the tenancy seam
  6. Secrets lifecycle: engineered, not exported
  7. Auditing identity decisions
  8. When to reach for this pattern
  9. Open risks
  10. Evaluation status
  11. Where to look

Declaring Runtime Intent — The Software Bill of Behavior

  1. Companion diagrams (editable drawio)
  2. 1. What an SBoB is — and what it is not
  3. 2. The contract, section by section
  4. 3. From contract to enforcement points: one transpilation, three stages
  5. 4. Collection: what each platform can honestly see
  6. 5. Day 1: earning the contract
  7. 6. Day 2: the drift triage loop
  8. 7. Worked example: the SBoB transpiler — three stages, one transpilation (DevelApp-ai)
  9. 8. When to reach for this pattern
  10. 9. Open risks
  11. 10. Checklist
  12. 11. Evaluation status
  13. 12. Works cited

Observed Behavior to Declared Intent — Bootstrapping an SBoB from Telemetry

  1. Companion diagrams (editable drawio)
  2. 1. The fidelity ladder: what may contribute an entry, and in what role
  3. 2. The derivation pipeline
  4. 3. Odd-behavior disposition: what happens to the strange entry
  5. 4. Windowing honestly: how long you must watch
  6. 5. The closed loop: drift is the fallback for what the window missed
  7. 6. When to reach for this pattern
  8. 7. Open risks
  9. 8. Checklist
  10. 9. Evaluation status
  11. 10. Works cited

Observability Engineering: The Telemetry Substrate

  1. The problem
  2. What you need
  3. The three signals and their contracts
  4. Instrumentation as code and context propagation
  5. Cardinality as a budget
  6. SLOs as measurement, not aspiration
  7. The hand-off seams
  8. Provenance, retention, and what the substrate costs
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

Storage and State at Scale

  1. The problem
  2. What you need
  3. Cache engineering: invalidation as a contract
  4. Replication: lag as a consistency surface
  5. Partitioning: keys chosen by access pattern
  6. Consistency as a spectrum, used deliberately
  7. Connection pooling: the state-isolation hazard
  8. The capacity model: will it fit?
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

Resilience, Capacity, and Disaster Recovery Drills

  1. The problem
  2. What you need
  3. The claim inventory: rehearsed versus asserted
  4. Backup as rehearsed engineering
  5. Chaos drills as scheduled practice, not stunts
  6. Capacity engineering: headroom bands, not surprises
  7. Disaster recovery as a written, tested plan
  8. SLO drills: closing the loop the ingress chapter opened
  9. Resilience economics: what redundancy actually costs
  10. When to reach for this pattern
  11. Open risks
  12. Evaluation status
  13. Where to look

Owning the Data

Enforceable Data Contracts

  1. The problem this chapter solves
  2. What you need
  3. The contract as an executable artifact
  4. Compatibility gates in CI
  5. CDC pipelines with quarantine
  6. Drift detection and the problem register
  7. When to reach for this pattern
  8. Open risks (stated plainly)
  9. Evaluation status
  10. Where to look

Evolving Data Schemas Without Downtime

  1. The problem
  2. What you need
  3. Expand: additive change as the default discipline
  4. Migration as artifact: schema and code move together
  5. The dual-write window and measurement-based cutover
  6. Backfill engineering: why naive UPDATE loops take production down
  7. Composing with contract compatibility gates
  8. Contract: the removal step
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

Engineering the Right to Be Forgotten

  1. The problem this chapter solves
  2. What you need
  3. Deletion fan-out: enumerate the copies before deleting any of them
  4. Scheduled deletion and on-request erasure are one machinery
  5. Cryptographic erasure: destroy the key instead of chasing the bytes
  6. Deletion evidence: certificates, sampling, reconciliation
  7. The AI wrinkle: regeneration and model memory
  8. When to reach for this pattern
  9. Open risks
  10. Evaluation status
  11. Where to look

Immutable Ledgers — Verification, Trading, and Certification

  1. The problem this chapter solves
  2. What you need
  3. What a blockchain actually is — and is not
  4. When a ledger earns its place
  5. Verification for open source — anchoring behavior contracts
  6. Trading between distrusting parties
  7. Certificates anyone can verify
  8. The costs, stated loudly
  9. Changing an immutable system — the upgrade methodology
  10. When to reach for this pattern
  11. Open risks
  12. Evaluation status
  13. Where to look

Building a Streaming and Batch Data Platform

  1. The problem
  2. What you need
  3. CDC as the spine
  4. The repair and replay loop
  5. Stream versus batch: a tradeoff, not a fashion choice
  6. Delivery semantics, honestly
  7. The lakehouse pattern at engineering level
  8. The contract seam
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

Data Quality, Lineage, and Cataloging

  1. The problem
  2. What you need
  3. Quality as gates: four families and a ladder
  4. The self-reporting pipeline as pattern precedent
  5. Lineage as a generated artifact
  6. The catalog: three fields, answerable questions
  7. Bad data is an incident
  8. When to reach for this pattern
  9. Open risks
  10. Evaluation status
  11. Where to look

Operating and Improving

Release Engineering and Progressive Delivery

  1. The problem
  2. What you need
  3. Artifact provenance: one build, promoted never rebuilt
  4. Environment promotion as a contract
  5. Progressive delivery mechanics
  6. Release as code
  7. Which changes need a planned release
  8. Rollback as first-class
  9. The DORA seam
  10. When to reach for this pattern
  11. Open risks
  12. Evaluation status
  13. Where to look

Incident-to-Action Engineering

  1. The problem this chapter solves
  2. What you need
  3. Severity before the incident; an alert creates a record
  4. Runbooks as code and the escalation clock
  5. Postmortems whose actions actually land
  6. Self-reporting systems: CI that files its own diagnostics
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

Building a DORA Metrics Pipeline

  1. The problem this chapter solves
  2. What you need
  3. The four keys from real events
  4. Making change failure rate well-defined
  5. Feeding the number onward without making it the target
  6. The honest caveats
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

Compliance as Code

  1. The problem this chapter solves
  2. What you need
  3. The SBOM in CI: what it does and does not prove
  4. Provenance and pin verification: trust bytes, not intentions
  5. Policy-as-code checks as pipeline steps
  6. ADR-as-code: supersede chains a machine can traverse
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

Behavior Deltas at the Release Gate — Supply-Chain Security from SBoB Diffs

  1. Companion diagrams (editable drawio)
  2. 1. The gate: a semantic diff with weights, not a YAML blob
  3. 2. Scoring the delta: thresholds that mean something
  4. 3. Why this catches what SBOM gates cannot
  5. 4. The review workflow: who signs, what they see
  6. 5. Anti-patterns, honestly
  7. 6. When to reach for this pattern
  8. 7. Open risks
  9. 8. Checklist
  10. 9. Evaluation status
  11. 10. Works cited

Publishing the Contract — SBoB Distribution, Signing, and Visibility

  1. Companion diagrams (editable drawio)
  2. 1. Two copies, one contract
  3. 2. The registry: git as the registry
  4. 3. Packaging channels: where the profile rides
  5. 4. Signing: two layers, one identity pin
  6. 5. Visibility: who may read the declaration
  7. 6. Anti-patterns, honestly
  8. 7. When to reach for this pattern
  9. 8. Open risks
  10. 9. Checklist
  11. 10. Evaluation status
  12. 11. Works cited

Enforcing Software Bills of Behavior

  1. Companion diagrams (editable drawio)
  2. 1. The gate: verify the package you are about to run
  3. 2. Fail-closed canonical parsing: reject, never repair
  4. 3. Policy as data: the rule set is a configuration object
  5. 4. The enforcing decorator: deny without invoking the runtime
  6. 5. The rollout ladder — and the default that protects strangers
  7. 6. Anti-patterns, honestly
  8. 7. When to reach for this pattern
  9. 8. Open risks
  10. 9. Checklist
  11. 10. Evaluation status
  12. 11. Works cited

Deterministic Documentation for Infrastructure Code

  1. The problem this chapter solves
  2. What you need
  3. Rendered from the source of truth
  4. Decisions as data: MoSCoW, ADRs, and rendered traceability
  5. The gate: policy-violating pull requests cannot merge
  6. When to reach for this pattern
  7. Open risks
  8. Evaluation status
  9. Where to look

Automated Code Review at the Pull Request Gate

  1. The problem this chapter solves
  2. What you need
  3. The gate: findings as review actions
  4. The analyzer fabric: one gate, many surfaces
  5. Security framing as an aid, not certification
  6. The trajectory of the pattern: criteria-aware review
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

A Branching Strategy That Earns Its Keep

  1. The problem this chapter solves
  2. What you need
  3. The default: a protected trunk and short-lived branches
  4. Release branches: earned by the risk matrix, not by the calendar
  5. Conflict resolution as a designed path
  6. Traceability: the ledger starts at the merge
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

Engineering Cloud Unit Economics

  1. The problem this chapter solves
  2. What you need
  3. The unit-cost metric: instrument the attribution, state the boundaries
  4. Budgets and anomaly alerts: ±20% as an operational signal
  5. Showback rate cards: the honest limits of chargeback
  6. Agentic demand: token burn as a forecastable curve
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

Composable Infrastructure Components

The Component Hierarchy — General, Customer, Project

  1. The problem this chapter solves
  2. What you need
  3. Three levels, one dependency direction
  4. What earns a level
  5. Platform classes and the operability contract
  6. Maintainability is the point
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

The Component Package — Signed, Versioned, Attested

  1. The problem this chapter solves
  2. What you need
  3. Package anatomy
  4. Signing and the three verification points
  5. Semver at infrastructure scale
  6. The mini-TDS — partially generated, never hand-copied
  7. Azure Well-Architected alignment where it does not conflict
  8. Hierarchy × package = maintainability
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

One Component, Many Fabrics — the Render Matrix

  1. The problem this chapter solves
  2. What you need
  3. The render matrix as a versioned artifact
  4. Tool honesty per row
  5. The abstraction boundary: contract to renders
  6. Workload operability across substrates
  7. Second-day operations live in other repos
  8. Coverage reality in the demonstration estate
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

Network Components — Segmentation, Enclaves, and Diodes as Building Blocks

  1. The problem this chapter solves
  2. What you need
  3. The network component taxonomy
  4. Renditions per environment
  5. Diodes as components — with honesty
  6. Evidence and promotion as shipped tests
  7. When to reach for this pattern
  8. Open risks
  9. Evaluation status
  10. Where to look

Policy as Code and Compliance as Components

  1. The problem this chapter solves
  2. What you need
  3. Policy components at every level
  4. One policy source, N fabric renders
  5. Compliance as code at component scale
  6. Company-domain specialization mechanics
  7. Supply-chain security audits as pipelines
  8. When to reach for this pattern
  9. Open risks
  10. Evaluation status
  11. Where to look

Securing the Component Supply Chain

  1. The problem this chapter solves
  2. What you need
  3. The threat model, mapped to gates
  4. DevSecOps in the component pipeline
  5. Sign everything that ships; verify at every gate
  6. Company-domain adjustments
  7. IAM without lock-in — the broker pattern
  8. Quarantine and kill paths
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

Baking Images, Patching, and the Component Lifecycle

  1. The problem this chapter solves
  2. What you need
  3. Packer baking as composition
  4. Patch handling with components
  5. Pull versus push — the tradeoff, stated
  6. SBoB enforcement across diodes and enclaves
  7. The component lifecycle
  8. Subcontractor deliveries — the non-component boundary
  9. When to reach for this pattern
  10. Open risks
  11. Evaluation status
  12. Where to look

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Earn $8 on a $10 Purchase, and $16 on a $20 Purchase

We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub