A hobbyist' digital garden

REX - Craft in a startup

3 min read

Speakers:

  • Anne JACQUET – Backend Engineer @IPPON & @auxo​
  • Philippe LEBOC – Backend Engineer @auxo - 15+ years of exp.

This talk offers a real-world look into how a small startup team applies software craft principles while building a system of microservices, emphasizing pragmatism, maintainability, and shared responsibility.​

1. Team Setup & Stack

  • Small dev team, no Product Owner: full autonomy and direct responsibility.
  • Stack: Spring Boot (Java) backend, Vue + TypeScript frontend.
  • Backend team also handles deployments and architecture decisions.

2. Developer Responsibilities Beyond Code

  • Importance of understanding:
    • How, where, and when code is deployed.
    • The full request lifecycle across services.
  • Encouragement of end-to-end awareness, not just “writing the feature.”

3. Microservices: Why & How

  • Services are intentionally isolated – no inter-service communication.
  • Comparison of synchronous vs. asynchronous service interactions.

Pros of Microservices:

  • Resilience
  • Scalability
  • Faster deployment cycles
  • Team autonomy
  • Cost optimization

Cons:

  • Increased infra complexity
  • Debugging becomes harder
  • Testing across services is complex
  • Data consistency challenges
  • More API contracts to manage and respect

4. Shared Libraries & Common Code

  • Several services share a common library:
    • Configuration, Auth, Serialisation, Pagination, Asserts
    • Helps standardize behavior and avoid code duplication.
  • Caution: not everything belongs in a shared lib — avoid dumping everything in.

5. Architecture: Hexagonal by Default

  • All services follow Hexagonal Architecture:
    • Focus on domain logic.
    • Clear boundaries and dependency inversion.
    • Enables parallel dev between frontend and backend.
    • Clear agreement on data structures and endpoints.

6. API Best Practices

  • PUT vs PATCH:
    • PUT = replace full object
    • PATCH = partial updates; doesn’t allow null, so deletions done via dedicated endpoints (e.g., DELETE /v1/object/attribute)
  • Pagination on every endpoint to standardize queries — avoids debate later.

7. Validation Strategy

  • Validation occurs both:
    • In domain layer (strict data control, no null)
    • At endpoint level using annotations (e.g., @NotNull, @Min, @Max)
  • Adds safety, debugging help, and serves as living documentation.
  • Shared assertion library supports readable, reusable validation logic.

8. Concurrency & Conflict Management

To handle multiple users updating the same data:

Pessimistic Locking

  • Locks data to prevent conflicts.
  • Reduces concurrency and can impact performance.

Optimistic Locking (preferred)

  • Allows concurrent attempts, but checks version before writing.
  • If DB version doesn’t match request version → reject the update.
  • Requires more logic but scales better.

9. Craftsmanship in Practice

  • Decisions are contextual, budget-aware, and value-driven.
  • Craft isn’t theoretical — it’s in every line of code, every decision.
  • Example: architecture, test strategy, validation style — all tailored for startup constraints.

Q&A Highlights

  • Q: How do you organize features and workload? A: Only two backend devs → rely on close communication and shared ownership of all services.
  • Q: Monolith first or microservices from the start? A: Chose microservices from the beginning, to support flexibility and service isolation.

Conclusion

  • Understand your system fully, not just your piece of it.
  • Use microservices intentionally: they solve problems, but bring new ones.
  • Favor Hexagonal Architecture to maintain clean, testable code.
  • Use shared libraries wisely to avoid duplication, but don’t let them bloat.
  • Handle concurrency with care — optimistic locking scales better.
  • Craft is not about perfection — it’s about making smart, deliberate trade-offs daily.

Graph View