Appearance

Concepts ​

Welcome to the conceptual foundation of Synapse Studios' development practices. This section provides the theoretical understanding and principles that guide our technical decisions.

What You'll Find Here ​

Our concepts documentation is organized into the areas below, which together form the foundation of how we think about software development:

Architecture ​

Explore the architectural principles that shape how we design and build systems. From understanding the fundamental forces of coupling and cohesion to implementing clean architecture patterns, these concepts provide the blueprint for scalable, maintainable applications.

Topics:

  • Coupling and Cohesion - The fundamental forces that determine code quality
  • Clean Architecture - Building systems that stand the test of time
  • Modular Monolith - Starting simple while planning for growth
  • Dependency Inversion - Creating flexible, testable architectures

Database ​

The database holds the system's shared, persistent state. Application code is replaced on every deploy while the data and its schema stay, and these concepts cover working with that state safely under continuous deployment.

Topics:

  • Schema Changes - Keeping migrations compatible with the running application
  • Query Design - What a pull request can see, and what only the running database answers
  • Data Modeling for Growth - Choices that hold up as a table grows
  • Cross-Module Data Access - Composing data without a shared-table join

UI ​

User interfaces are built by composing hierarchical, reusable components. These concepts apply across frameworks and are most directly relevant to our React work.

Topics:

  • Compositional UI - The fractal nature of component-based interfaces
  • Component Boundaries - Deciding where one component ends and the next begins
  • Composition Over Configuration - Building variation from parts instead of flags

Patterns ​

Discover the design patterns we use to solve recurring problems elegantly. These patterns provide proven solutions that improve code organization, maintainability, and team communication.

Topics:

  • Use Cases - Organizing business logic in a clear, testable way
  • Repository Pattern - Abstracting data persistence properly
  • Page Object Pattern - Structuring UI tests for maintainability

Testing ​

Understand our testing philosophy and the different testing strategies we employ. Learn not just the "how" but the "why" behind our testing practices.

Topics:

  • Unit Testing - Fast feedback and design validation
  • Test-Driven Development - Using tests to drive better design
  • Integration Testing - Verifying component interactions
  • Frontend Testing - Ensuring UI reliability and user experience
  • Acceptance Testing - Validating business requirements

CI/CD ​

Learn the foundational practices that enable frequent, reliable software delivery. Understand how Continuous Integration and Continuous Delivery reduce risk and make releases routine.

Topics:

  • Continuous Integration - Integrating work frequently with automated verification
  • Continuous Delivery - Ensuring software is always deployable

Infrastructure ​

Infrastructure code provisions real, stateful systems, and a Terraform configuration is both a program and a record of what exists in a cloud account. These concepts cover the reasoning behind how we structure and change that code.

Topics:

  • Terraform State Boundaries - What a root module boundary buys, and what each one costs
  • Terraform Module Philosophy - When a module earns its keep, and how shared modules evolve
  • Terraform Change Control - Single-writer changes, pre-merge applies, and drift

Practices ​

Learn the team-level processes and behaviors that enable effective collaboration and continuous improvement. While technical concepts guide how we build software, practices guide how we work together and learn from our experiences.

Topics:

  • Postmortems - Learning from failures through blameless investigation
  • Blameless Culture - Creating psychological safety for honest discussion
  • Root Cause Analysis - Finding systemic issues, not individual mistakes
  • Action Items - Turning lessons into systemic improvements

Working with Legacy Code ​

Learn pragmatic approaches for improving existing codebases that don't conform to current standards. Discover how to incrementally modernize systems while continuing to deliver value.

Topics:

  • Characterization Tests - Making untested code safe to change
  • Finding Seams - Identifying boundaries for safe refactoring
  • Strangler Fig Pattern - Gradually replacing legacy functionality
  • Branch by Abstraction - Safe concurrent modifications
  • Displacement Patterns - Routing around legacy constraints
  • The Boy Scout Rule - Continuous incremental improvement

How to Use This Section ​

  1. Start with Architecture if you're new to our development approach
  2. Reference Patterns when designing new features or refactoring existing code
  3. Consult Testing to understand what and how to test effectively
  4. Read Database and UI when the work touches persistent state or the component layer
  5. Study CI/CD to understand how to integrate and deliver software frequently and safely
  6. Read Infrastructure before changing how a project's cloud resources are provisioned
  7. Explore Practices to learn team-level processes for collaboration and continuous improvement
  8. Apply Legacy Code techniques when working with existing codebases that need improvement

Next Steps ​

After understanding these concepts, explore our Implementation guides to see how these principles are applied in specific technologies and frameworks.