Data Modeling & Schema Design

Creates basic Ecto schemas with field types and validations through changeset in Elixir projects. Defines has_many, belongs_to and many_to_many associations. Uses embedded_schema for nested structures and cast_assoc for validating associated data.

Designs simple data schemas for Go services: tables with correct types, foreign keys, basic normalization to 3NF. Describes models via GORM tags or golang-migrate SQL files, understands one-to-many and many-to-many relationships.

Designs simple data schemas with JPA: Entity, @OneToMany/@ManyToMany relationships, embedded types. Understands normalization. Uses @Enumerated, @Temporal for column typing.

Designs models via Prisma schema: models, relations (1:1, 1:N, M:N), enums. Understands normalization. Uses Prisma relations for type-safe data access.

Designs simple schemas: tables, one-to-one, one-to-many, many-to-many relationships. Normalizes to 3NF. Chooses correct data types. Understands when soft delete is needed.

Creates basic schemas with tables and relationships. Understands 1:1, 1:N, N:M relationships. Applies normalization up to 3NF. Uses proper data types.

Designs simple data models for Rust applications, creating struct definitions with derive(sqlx::FromRow) or Diesel schemas. Understands mapping between Rust types and PostgreSQL, uses Option<T> for nullable fields and enum types through sqlx::Type.

Creates basic data models for Scala applications: defines case classes for domain entities, maps them to PostgreSQL tables through Doobie or Slick. Understands normalization to 3NF, designs simple table relationships and uses Scala types to express model constraints.

Understands data modeling basics: star and snowflake schemas, fact and dimension tables. Follows team conventions for building BI-optimized data models. Uses existing dimensional models to build accurate reports and dashboards.

Understands relational data modeling fundamentals: normalization, primary/foreign keys, and entity relationships. Follows team patterns for structuring analytical tables. Uses ER diagrams to understand data dependencies for accurate analysis.

Designs data warehouse tables: star schema (fact + dimension), SCD types (Type 1, 2). Creates staging, intermediate and mart layers. Understands normalization and denormalization for analytics.

Designs simple schemas: normalization up to 3NF, data type selection, constraints (NOT NULL, UNIQUE, FK). Creates ER diagrams for small modules. Understands the difference between OLTP and OLAP modeling.

Creates basic data models for fullstack features: tables with proper types, foreign keys, NOT NULL constraints. Understands the connection between database schema, backend types (TypeScript interfaces) and frontend data structure.

Understands basic data modeling principles: entities, relationships and normalization. Knows data structures for storing ML metadata: experiments, models, datasets and metrics.

Independently designs schemas and optimizes queries with data modeling. Understands indexing and query execution plans. Uses Ecto effectively.

Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses sqlx/GORM effectively.

Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.

Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses Prisma/TypeORM effectively.

Designs data schemas for business domains: normalization to 3NF, denormalization for performance, polymorphic relationships. Models soft deletes, record versioning, audit logs. Chooses between EAV and JSON columns for flexible attributes.

Designs schemas for microservices. Applies denormalization for performance. Models polymorphic relationships (STI, MTI). Designs audit trails and soft deletes. Uses JSONB for flexible data.

Independently designs schemas and optimizes queries with data modeling and schema design. Understands indexing and query execution plans. Uses diesel/sea-orm effectively.

Independently designs schemas and optimizes queries with Data Modeling and Schema Design. Understands indexing and query execution plans. Uses Slick/Doobie effectively.

Independently designs dimensional models for BI reporting. Implements slowly changing dimensions (SCD Type 1/2), conformed dimensions, and aggregate tables. Optimizes data models for dashboard query performance with proper indexing and partitioning.

Independently designs analytical data models with appropriate normalization levels. Implements materialized views and summary tables for recurring analysis patterns. Understands trade-offs between normalized and denormalized schemas for analytical workloads.

Designs dimensional models: Kimball methodology (conformed dimensions, bus matrix), Data Vault (hubs, links, satellites). Applies SCD Type 2 with effective dates. Models semi-structured data.

Designs production schemas: choosing between normalization and denormalization by workload, partitioning strategy, data archiving. Considers growth patterns when selecting data types and partition keys.

Independently designs schemas and optimizes queries with data modeling and schema design. Understands indexing and query execution plans. Uses Prisma/SQLAlchemy effectively.

Designs data schemas for ML platform: feature store schema, experiment metadata, model registry and prediction logs. Applies patterns for data and model versioning with lineage tracking.

Designs complex data models with Ecto for PostgreSQL: polymorphic associations, STI through type field, JSONB columns with Ecto.Type. Implements custom Ecto.Types for domain-specific types, applies Ecto.Changeset for complex business validation with contexts.

Designs optimal data schemas for Go microservices: denormalization strategies for read-heavy workloads, JSON columns in PostgreSQL, partitioning. Develops domain models through clean architecture with entity and value object separation.

Designs domain models for Java services: Aggregates in JPA, Value Objects via @Embeddable, soft deletes via @Where, audit via @EntityListeners. Chooses between JPA and documents (MongoDB) based on context.

Designs domain models: DDD aggregates via Prisma, value objects via embedded types, soft deletes via middleware. Chooses relational vs document model based on context.

Designs schemas for complex domains: polymorphic relationships, EAV for flexible attributes, temporal data, audit trails. Applies denormalization for production. Models bounded contexts.

Designs domain models for complex business domains. Applies DDD in modeling. Designs event-sourced storage. Optimizes schema for read-heavy and write-heavy workloads.

Develops domain data models for Rust services with separation into persistence and domain layers. Applies newtype patterns for ID types (UserId(Uuid)), JSONB for flexible attributes through serde, and designs normalized schemas considering query patterns.

Designs domain data models for Scala services: applies DDD approach with sealed trait ADTs for states, JSONB for flexible structures, temporal tables for auditing. Optimizes schemas considering access patterns, implements efficient serialization through Circe and Doobie codecs.

Designs enterprise-grade dimensional models spanning multiple business domains. Implements Data Vault 2.0 patterns for historical tracking and auditability. Architects semantic layers that bridge physical data models with business-friendly abstractions.

Designs complex analytical data models for cross-domain analysis with optimized query patterns. Implements advanced modeling techniques: bridge tables, factless facts, and accumulating snapshots. Mentors analysts on modeling best practices and schema evolution.

Designs enterprise data models: Data Vault 2.0 for flexibility, Anchor Modeling for high-change environments, wide tables for ClickHouse. Defines layered architecture: raw → staging → curated → mart.

Designs data models for high-load systems: sharding with data distribution awareness, temporal tables, polymorphic associations. Defines schema evolution strategy: backward compatible changes, expand-and-contract pattern.

Designs data models for fullstack applications across the entire stack: normalized database schema, DTO transformation on backend, normalized store on frontend. Applies DDD approach, separates read/write models and optimizes for UI usage patterns.

Develops comprehensive ML platform data model with multi-tenant support, schema evolution and time-travel queries. Designs data contracts between producers and consumers in ML pipelines.

Defines data model architecture for the Elixir platform. Designs bounded contexts through separate Ecto schemas and Phoenix contexts. Implements event sourcing with Commanded/EventStore, defines aggregate and value object modeling standards through embedded_schema.

Defines data modeling standards for the Go platform: naming conventions, partitioning policies, multi-tenant data strategies. Reviews team data architecture, ensuring consistency across microservices.

Defines data modeling standards: JPA conventions, naming strategy, schema documentation. Reviews models for DDD compliance and performance implications.

Defines modeling standards: naming conventions, Prisma schema conventions, documentation. Reviews models for DDD compliance and performance impact.

Defines data modeling standards: naming conventions, mandatory fields (timestamps, soft deletes), schema versioning approach. Reviews models for new modules.

Defines data modeling standards for the organization. Designs cross-service data architecture. Implements data governance. Trains the team.

Designs data models for Rust microservice platform: bounded contexts with separate schemas, event sourcing through append-only tables. Develops shared domain type libraries (domain-primitives crate) and serialization standards through serde for inter-service exchange.

Defines data modeling standards for Scala team: schema design rules, table naming, JSONB vs normalization usage. Reviews domain models for bounded context alignment, implements Event Sourcing models with Akka Persistence for critical aggregates.

Defines data modeling standards for BI organization. Establishes naming conventions, modeling guidelines, and review processes. Coordinates dimensional model governance across teams with conformance rules and shared dimension management.

Defines data modeling standards across analytical teams. Establishes schema design review processes, migration guidelines, and backward compatibility rules. Drives adoption of consistent modeling patterns and shared analytical data marts.

Defines data modeling standards: naming conventions, documentation requirements, review process. Chooses approach (Kimball vs Inmon vs Data Vault) by context. Trains team on modeling best practices.

Defines data modeling standards: naming conventions, data types per DBMS, partitioning guidelines. Conducts design reviews for critical schemas. Coordinates data modeling practices between product and DBA teams.

Defines data modeling architecture for the fullstack platform: single source of truth in database schema, type auto-generation for backend and frontend through Prisma/GraphQL codegen. Establishes naming and model evolution standards for the team.

Defines data modeling standards for organizational ML ecosystem: feature schemas, model signatures, dataset catalogs. Designs unified data model linking experiments, models and production metrics.

Develops data modeling strategy at the entire organizational level. Defines DDD standards with Ecto contexts and bounded contexts, designs inter-domain integration through events. Implements CQRS with Commanded for complex business domains in the Elixir ecosystem.

Shapes organizational data modeling strategy: OLTP and OLAP schema design standards, data governance policies, master data. Develops platform tools for visualization and validation of data schemas across all Go services.

Designs platform data model: bounded context → database mapping, shared entities via domain events, data mesh principles. Defines schema evolution strategy without breaking changes.

Designs platform data model: bounded context → database mapping, shared types via npm packages, event-driven data sync between services.

Designs data model at platform level: shared vs isolated databases, data mesh, cross-service data contracts. Defines organizational data model evolution strategy.

Shapes data architecture strategy. Designs enterprise data model. Defines data mesh principles.

Defines organizational data modeling strategy: DDD approaches with aggregate roots as Rust structs, CQRS with projection tables, multi-model storage. Establishes data governance standards, event schema registry and master data management architecture.

Makes strategic decisions on platform data architecture: choosing between relational and event-driven models, Schema Registry standards for inter-service communication. Defines Data Mesh approach for Scala microservices, designs data models considering scalability, compliance and analytics requirements.

Defines enterprise data modeling strategy spanning operational and analytical systems. Evaluates modeling methodologies (Kimball, Inmon, Data Vault) and shapes organizational standards. Drives data model governance framework aligned with data mesh principles.

Shapes enterprise analytical data modeling vision and cross-domain schema standards. Drives organizational adoption of modern modeling practices (Activity Schema, One Big Table patterns). Defines long-term data architecture roadmap with modeling methodology choices.

Designs organizational data modeling strategy: domain-driven data models, canonical data model, data mesh domain boundaries. Defines governance for entity resolution and master data management.

Shapes organizational data modeling strategy: domain-driven data design, data mesh principles, enterprise data model. Defines modeling standards for different DBMSes and use cases, including multi-model approaches.

Shapes organizational data modeling strategy: domain-driven design in fullstack context, model versioning, schema evolution without breaking changes. Designs platform for managing data models at scale across multiple products.

Shapes ML platform data management strategy with data mesh approach and domain-driven design. Defines data governance architecture for ML: data quality, privacy, lineage and compliance at organizational scale.