Design Tools for Junior Developers Looking Beyond CRUD

You've finished your CRUD features, but now the fear of maintenance is setting in. The habit of starting with table design often leads to a tangled system. This article contains specific methodologies to help you decouple code into domain units and standardize your environment, effectively narrowing the scope of modifications.

Increasing Code Cohesion: Separating Data Access and Logic

If business logic is mixed into your controllers, you have to tear apart your code every time the database structure changes. Adopt a layered architecture to isolate the two. This can reduce your codebase maintenance time by approximately 40%.

Here are the steps to separate data access and logic:

Move validation code from controllers to request DTOs and use validation annotations.
Collect logic scattered across transaction scripts into methods inside domain entities.
Declare interfaces that define persistence behaviors instead of using specific DB drivers, separating them from the domain layer.

Even if a specific table schema changes, the core rules remain intact.

Creating a Test Environment with Dependency Injection

If you create objects directly inside a class using the new operator, unit testing becomes impossible. Realize Inversion of Control (IoC) to perform independent tests with Mock objects without needing an external server.

These are practical steps to increase testing efficiency:

Declare collaborators used by objects as interfaces, not concrete classes.
Configure an external container to inject the appropriate implementation at runtime.
Use tools like @automock/jest to automate the configuration of test doubles.

Using this structure can improve your test execution speed by over 20%.

Isolating Entities and DTOs

If you map UI structures and DB tables one-to-one, you'll end up having to modify the DB schema just to fix a single screen. Strictly separate your DTOs for network messages from your domain entities.

Here is how to isolate them using mappers:

Create pure mapper classes dedicated solely to data conversion.
Move data only within the mapper to prevent direct dependencies between DTOs and entities.
Force the service layer to use only entities.

Even if you replace the data store, no logic modifications will be required.

Standardizing Development Environments with Docker Compose

When local environments differ from developer to developer, collaboration comes to a halt. Write your infrastructure as code using Docker Compose to synchronize environments.

Here are the steps to build a standard environment:

Write the versions and environment variables for your DB and cache servers in the docker-compose.yml file.
Place initial schema SQL files in the /docker-entrypoint-initdb.d path using volume mounts.
Use a package linker like pnpm Workspaces to prevent dependency tangles.

Once this configuration is complete, you can spin up a standard infrastructure in under 3 seconds without worrying about local machine settings.

Modeling Domains Before Designing Tables

If you start by drawing ERDs, you only end up with data-oriented, fragmented logic. Shopify transitioned over 800 engineers away from a legacy system centered on physical schemas toward modeling based on business objects.

These are the steps to start domain modeling:

List the main nouns and verbs of the domain based on use cases and ubiquitous language.
Define entities that require state transitions and value objects with immutable properties.
Determine aggregate roots to verify business integrity at the transaction unit level.

This approach confines the scope of modifications within a specific module even when requirements change. Designing complex systems is the most practical alternative to overcome feeling overwhelmed.

Design Tools for Junior Developers Looking Beyond CRUD

Increasing Code Cohesion: Separating Data Access and Logic

Here are the steps to separate data access and logic:

Move validation code from controllers to request DTOs and use validation annotations.
Collect logic scattered across transaction scripts into methods inside domain entities.
Declare interfaces that define persistence behaviors instead of using specific DB drivers, separating them from the domain layer.

Even if a specific table schema changes, the core rules remain intact.

Creating a Test Environment with Dependency Injection

These are practical steps to increase testing efficiency:

Declare collaborators used by objects as interfaces, not concrete classes.
Configure an external container to inject the appropriate implementation at runtime.
Use tools like @automock/jest to automate the configuration of test doubles.

Using this structure can improve your test execution speed by over 20%.

Isolating Entities and DTOs

Here is how to isolate them using mappers:

Create pure mapper classes dedicated solely to data conversion.
Move data only within the mapper to prevent direct dependencies between DTOs and entities.
Force the service layer to use only entities.

Even if you replace the data store, no logic modifications will be required.

Standardizing Development Environments with Docker Compose

When local environments differ from developer to developer, collaboration comes to a halt. Write your infrastructure as code using Docker Compose to synchronize environments.

Here are the steps to build a standard environment:

Write the versions and environment variables for your DB and cache servers in the docker-compose.yml file.
Place initial schema SQL files in the /docker-entrypoint-initdb.d path using volume mounts.
Use a package linker like pnpm Workspaces to prevent dependency tangles.

Once this configuration is complete, you can spin up a standard infrastructure in under 3 seconds without worrying about local machine settings.

Modeling Domains Before Designing Tables

These are the steps to start domain modeling:

List the main nouns and verbs of the domain based on use cases and ubiquitous language.
Define entities that require state transitions and value objects with immutable properties.
Determine aggregate roots to verify business integrity at the transaction unit level.

This approach confines the scope of modifications within a specific module even when requirements change. Designing complex systems is the most practical alternative to overcome feeling overwhelmed.

Design Tools for Junior Developers Looking Beyond CRUD

Related Video

Please STOP Building CRUD Projects (Common Dev Mistake)

Design Tools for Junior Developers Looking Beyond CRUD

Increasing Code Cohesion: Separating Data Access and Logic

Creating a Test Environment with Dependency Injection

Isolating Entities and DTOs

Standardizing Development Environments with Docker Compose

Modeling Domains Before Designing Tables

More from the community

사내 시스템에 llm api 붙일 때 마주하는 현실적인 한계와 대응법

레거시 백엔드에 GPT-6 Astra 붙일 때 예산 승인과 보안 통과를 먼저 끝내는 법이 있습니다

에이전트끼리 대화하다 6천만 원 청구서가 나오는 이유

사내 RAG 벡터 검색에 Okta 권한 필터를 직접 거는 방법

브라우저 에이전트에게 내 구글 계정을 통째로 넘기면 안 되는 이유

Apple Won the AI Race

Comments (0)

Design Tools for Junior Developers Looking Beyond CRUD

Increasing Code Cohesion: Separating Data Access and Logic

Creating a Test Environment with Dependency Injection

Isolating Entities and DTOs

Standardizing Development Environments with Docker Compose

Modeling Domains Before Designing Tables