dcupl vs Alternatives

Understanding how dcupl compares to other data solutions helps you choose the right tool for your project. This guide compares dcupl with popular alternatives across different categories.

Quick Comparison Table

Understanding the Categories

Before diving into detailed comparisons, it helps to understand what category each tool falls into:

flowchart TB
  subgraph backend["Backend Services"]
    FIREBASE["Firebase
Real-time Database"]
    SUPABASE["Supabase
Postgres Backend"]
    SEARCH["Elasticsearch/Algolia
Search Services"]
  end

  subgraph frontend["Frontend Libraries"]
    DCUPL["dcupl
Client-side Query Engine"]
    TANSTACK["TanStack Query
Server State Cache"]
    REDUX["Redux
State Management"]
  end

  APP[Your Application]

  backend --> APP
  frontend --> APP

dcupl is unique because it brings query capabilities typically found in backend services to the client side.

dcupl vs Firebase

Firebase is Google's Backend-as-a-Service platform with real-time database capabilities.

Key Differences

When to Choose Firebase

• You need real-time multi-user synchronization (collaborative editing, chat)
• Your data changes frequently and must be instantly reflected across clients
• You need user authentication built into your data layer
• Your dataset is too large to load into client memory

When to Choose dcupl

• You need instant filter and search without network latency
• Your data is read-heavy with infrequent updates
• You want to reduce server costs by offloading computation to clients
• You need complex faceted search like product catalogs

Code Comparison

// dcupl: Query runs instantly in browser
const list = dcupl.lists.create({ modelKey: 'Product' });

list.catalog.query.addCondition([
  { attribute: 'category', operator: 'eq', value: 'Electronics' },
  { attribute: 'price', operator: 'lte', value: 500 },
]);

// Instant results, no network request
const results = list.catalog.query.items();
const facets = list.catalog.fn.facets({ attribute: 'brand' });

// Firebase: Each query hits the server
const q = query(
  collection(db, 'products'),
  where('category', '==', 'Electronics'),
  where('price', '<=', 500)
);

// Network request required
const snapshot = await getDocs(q);
// Facets require separate queries or Cloud Functions

dcupl vs Supabase

Supabase is an open-source Firebase alternative built on PostgreSQL.

Key Differences

When to Choose Supabase

• You need a full backend with authentication, storage, and edge functions
• You prefer SQL and relational data modeling
• You need row-level security policies
• Your application requires write-heavy operations

When to Choose dcupl

• Your frontend team needs to move fast without backend dependencies
• You want instant client-side filtering without API round-trips
• You're building a read-heavy application like a catalog or dashboard
• You need SSR-compatible data that works the same on server and client

Architecture Comparison

flowchart LR
  subgraph supabase["Supabase Architecture"]
    direction LR
    S_APP[App] --> S_API[PostgREST API]
    S_API --> S_DB[(PostgreSQL)]
  end

flowchart LR
  subgraph dcupl["dcupl Architecture"]
    direction LR
    D_DATA[Data Source] --> D_SDK[dcupl SDK]
    D_SDK --> D_APP[App]
  end

With Supabase, every query goes to the server. With dcupl, data loads once, then all queries are instant.

dcupl vs TanStack Query

TanStack Query (formerly React Query) is a server state management library for fetching, caching, and updating data.

Key Differences

When to Choose TanStack Query

• You already have well-designed APIs with filtering and pagination
• You need to cache and synchronize server state
• Your data is too large to load entirely to the client
• You need real-time updates via WebSocket subscriptions

When to Choose dcupl

• You want built-in filtering, sorting, and faceting without building APIs
• Your dataset fits in memory and benefits from instant local queries
• You're building a product finder, data table, or catalog interface
• You want to prototype quickly without backend work

Complementary Usage

dcupl and TanStack Query can work together:

// Use TanStack Query to fetch data, dcupl to query it
const { data } = useQuery({
  queryKey: ['products'],
  queryFn: fetchProducts,
});

// Once data is loaded, dcupl handles all filtering
useEffect(() => {
  if (data) {
    dcupl.data.set('Product', data);
    dcupl.init();
  }
}, [data]);

// TanStack Query: fetching & caching
// dcupl: filtering & faceting

dcupl vs Redux

Redux is a predictable state container for JavaScript applications.

Key Differences

When to Choose Redux

• You need complex application state beyond data (UI state, user preferences)
• You want time-travel debugging and state inspection
• Your team is already proficient with Redux patterns
• You need fine-grained control over state updates

When to Choose dcupl

• Your state is primarily data that needs filtering and aggregation
• You want built-in query capabilities without writing reducers
• You're building a data-driven UI (catalogs, tables, dashboards)
• You prefer less boilerplate for data operations

Code Comparison

// dcupl: Filtering is built-in
const list = dcupl.lists.create({ modelKey: 'Product' });

list.catalog.query.addCondition([
  { attribute: 'inStock', operator: 'eq', value: true },
]);

// Get filtered items and facets
const items = list.catalog.query.items();
const brands = list.catalog.fn.facets({ attribute: 'brand' });

// Redux: You implement filtering logic
const selectFilteredProducts = createSelector(
  [selectProducts, selectFilters],
  (products, filters) => {
    return products.filter(p => {
      if (filters.inStock && !p.inStock) return false;
      // ... more filter logic
      return true;
    });
  }
);

// Facets require additional selectors
const selectBrandCounts = createSelector(
  [selectFilteredProducts],
  (products) => {
    // Count by brand manually
  }
);

dcupl vs Elasticsearch / Algolia

Elasticsearch and Algolia are search-as-a-service platforms optimized for full-text search.

Key Differences

When to Choose Elasticsearch/Algolia

• You need advanced full-text search with typo tolerance and synonyms
• Your dataset has millions of documents
• You need relevance ranking and machine learning features
• Search is a core differentiator for your product

When to Choose dcupl

• You need structured filtering more than fuzzy text search
• Your dataset is under 100k items
• You want zero search infrastructure to manage
• You need instant results without any network latency
• You want to avoid per-search costs

Hybrid Approach

Use both for the best of both worlds:

flowchart LR
  USER[User] --> UI[Search UI]
  UI --> |"Full-text search"| ALGOLIA[Algolia]
  ALGOLIA --> |"Return IDs"| UI
  UI --> |"Filter by IDs"| DCUPL[dcupl SDK]
  DCUPL --> |"Facets & details"| UI

// Use Algolia for text search, dcupl for filtering
const searchResults = await algoliaIndex.search(query);
const matchingIds = searchResults.hits.map(h => h.objectID);

// Filter dcupl data to matching IDs
list.catalog.query.addCondition([
  { attribute: 'key', operator: 'in', value: matchingIds },
]);

// dcupl provides facets for the search results
const facets = list.catalog.fn.facets({ attribute: 'category' });

Decision Framework

Use this flowchart to help decide:

flowchart TD
  START[What do you need?] --> Q1{Real-time
multi-user sync?}
  Q1 --> |Yes| FIREBASE[Firebase/Supabase]
  Q1 --> |No| Q2{Full-text search
with typo tolerance?}
  Q2 --> |Yes| Q3{Dataset > 100k items?}
  Q3 --> |Yes| SEARCH[Elasticsearch/Algolia]
  Q3 --> |No| DCUPL_SEARCH[dcupl + basic search]
  Q2 --> |No| Q4{Dataset fits
in memory?}
  Q4 --> |Yes| Q5{Need filtering,
facets, aggregations?}
  Q5 --> |Yes| DCUPL[dcupl]
  Q5 --> |No| TANSTACK[TanStack Query]
  Q4 --> |No| Q6{Need SQL?}
  Q6 --> |Yes| SUPABASE[Supabase]
  Q6 --> |No| TANSTACK2[TanStack Query + API]

Summary

dcupl shines when you need instant, client-side data exploration for datasets that fit in memory. It eliminates network latency for queries, reduces server costs, and provides built-in filtering and faceting that would otherwise require significant backend work.

Next Steps

• What is dcupl? - Understand dcupl's core value proposition
• Architecture - Learn how dcupl components work together
• Quick Start - Try dcupl in your project