What RowOps Is Not
This page exists to eliminate incorrect assumptions early. RowOps is a data ingestion platform with specific boundaries. Understanding what the system does not attempt is as important as understanding what it does.
Not a Spreadsheet Editor
RowOps processes tabular data through a pipeline. It is not an interactive editing environment.
What this means:
- No per-cell editing interface
- No drag-and-drop row manipulation
- No formula evaluation or cell references
- No undo/redo stack for individual edits
The pipeline operates on rows as units. Users cannot manually adjust values within the pipeline itself.
Not an ETL Scheduler
RowOps executes pipelines when invoked. It does not provide built-in scheduling, queuing, or orchestration.
What this means:
- No cron-style job scheduling
- No retry queues for failed imports
- No branching workflow orchestration
- No built-in triggers based on external events
Pipeline execution is synchronous from the caller's perspective. Orchestration, if needed, must be provided by the calling system.
Not a Data Warehouse
RowOps processes data in transit. It does not persist row-level datasets for later querying.
What this means:
- No SQL query interface over imported data
- No long-term storage of row content
- No data lake or columnar storage backend
- No historical data versioning
Metadata and configuration are persisted. No evidence found that row-level data is persisted server-side after pipeline execution.
Not Network-Free by Default
RowOps's headless package defaults to server-side license verification unless you provide a signed entitlement token.
What this means:
- Secret-key initialization contacts
https://api.rowops.dev/api/license/verifyfor license verification - Offline strict mode requires a signed
entitlementToken - Demo mode (100-row limit) is available without network but includes watermarking
The system is designed for client-side data processing, but license enforcement is server-assisted by default.
Not a Connector Marketplace
RowOps provides file parsing and pipeline execution. It does not provide pre-built integrations with external systems.
What this means:
- No native connectors to databases, CRMs, or SaaS platforms
- No OAuth flow management for third-party services
- No pre-built destination adapters beyond webhook delivery
- Sync targets are configured per-project but execution is client-driven
Data delivery to external systems occurs via the Sync module with user-provided endpoints, not through managed connectors.
Not Feature-Complete Across All Modules
Several modules are stubs or partial implementations. The system is actively evolving.
Observed module status:
pii-detect: Stub onlytransform: Partial implementationmask: Partial implementationembed: Minimal
Some parser formats (JSON, XML, HTML, Fixed-Width) are not yet exposed.
Not a Cryptographically Isolated System
The term "privacy-first" describes a design goal, not a verified property. Some server-side interactions exist.
What this means:
- Webhook payloads are delivered client-side, but webhook secret management and delivery logging occur server-side
- Usage tracking endpoints persist client-provided metadata with hostname and publishable key
- Telemetry payloads are strict allowlist, flat, and validated; still treat them as client-provided metadata
The system aims to process row-level data client-side. Server-side persistence is limited to metadata and configuration, but this boundary is not cryptographically enforced.
Summary
RowOps is a data ingestion pipeline, not a general-purpose data platform. It has deliberate boundaries:
| Expectation | Reality |
|---|---|
| Interactive spreadsheet | Row-based pipeline processing |
| Scheduled ETL jobs | On-demand execution only |
| Persistent data warehouse | Transient processing, metadata persistence |
| Network-free operation | Requires entitlement token or demo (100-row limit + watermark) |
| Connector marketplace | User-configured sync targets |
| Complete module coverage | Some modules are stubs or partial |
| Verified privacy-first | Design goal with server-side interactions |
Understanding these boundaries prevents misaligned expectations during integration.