Data pipeline requirements checklist: how to use this page
If you are choosing or building pipelines that feed a warehouse such as ClickHouse, write your requirements before you choose between Airflow, Dagster, Airbyte, Kafka or NiFi. This page gives you that requirements list. Each item covers a decision you must make about sources and destinations, batch versus streaming, volumes and latency, orchestration, connectors, schema changes, data quality, lineage, secrets, backfills, and where sensitive data may flow. Each requirement comes with a verification step, so you can test a candidate tool or partner proposal against it rather than accept a feature list at face value.
Treat the licensing and version facts on this page as inputs to verification, not conclusions. For example, Apache Airflow and Dagster are both Apache-2.0 licensed, but the Dagster feature set that covers role-based access, SSO, column lineage and audit logs is documented as part of Dagster+ rather than open-source Dagster, and Airbyte's platform repository uses the Elastic License 2.0. Confirm each license against the upstream repository, confirm which release line you would deploy, and check whether your required features sit in the open-source edition. Ask the same questions of Kafka, whose supported releases and security mechanisms change between versions.
Use the checklist in two places. In procurement, send the requirements to every shortlisted option and ask for written answers and evidence for each verification step. In design reviews, walk the list with data engineering, security and the owners of the source and destination systems, and record which requirements are open. The checklist does not replace a written scope. Once requirements are settled, the scope document should name the systems, data classes, deliverables, acceptance tests and responsibilities for each party, and it should be agreed in writing before work starts.
Functional requirements: sources, destinations, latency and volumes
This table lists the functional requirements a pipeline must meet before a platform is chosen, with why each one matters and how to verify it. Use it as a working checklist with your data owners and engineers. The main takeaway is that connector coverage, latency and volume claims should be tested against your own extracts, not assumed from a product page.
| Requirement | Why it matters | How to verify |
|---|---|---|
| Source and destination inventory | Every source system, owner, data class and destination must be known before connectors or DAGs are designed. Missing sources are the most common source of scope change. | Build a register of systems, owners, data classes and refresh needs. Confirm each source's access method with its owner and the connector's documentation. |
| Batch versus streaming decision | Batch suits daily or hourly loads and reconciliations. Streaming suits event-driven use cases where consumers need records within seconds or minutes. Mixing them without a decision adds cost and operating load. | For each feed, record the consumer's required freshness and the business consequence of a delay. Confirm the decision with the consumer, not only the engineering team. |
| Volumes and growth | Initial load, daily change volume and peak bursts drive broker, worker and storage sizing. Growth over the planned retention period matters as much as today's size. | Test with real extracts, including the largest month-end or peak run. Measure row counts, bytes and change rates per source and project growth over the retention period. |
| Latency targets | End-to-end latency includes extraction, transit, transformation and load. A fast broker does not help if the warehouse load runs only nightly. | Define a measurable target per feed, such as time from source change to queryable record. Measure each stage during a load test. |
| Orchestration and scheduling needs | Dependencies, retries, SLAs and backfill windows determine whether a scheduler or asset-based orchestrator fits. Airflow 3.3.2 and Dagster 1.13.26 are current release references to check against. | Document dependencies and failure handling per pipeline. Confirm the version in use against the Airflow version life cycle and the Dagster releases page before planning upgrades. |
| Kafka release and support status | Only supported Kafka releases receive bugfixes. The supported releases listed are 4.3.1, 4.2.2 and 4.1.2, and older versions are archived. | Confirm the target version is on the Kafka downloads page as supported. Plan upgrades within the rolling upgrade path the project documents. |
| Connector coverage | Connectors differ in supported sources, incremental modes, schema handling and licensing. Coverage claims in marketing material may not match your exact source version. | Confirm each source and version in the connector's own documentation. Run a test extract against a non-production copy of each source. |
| Source system load and access windows | Extraction can slow production systems or conflict with maintenance windows, which shapes schedules and incremental strategy. | Agree extraction windows and query limits with system owners. Confirm whether change data capture or replicas are available. |
Batch or streaming: which requirement decides the architecture
The first requirement to settle is how quickly each consumer needs data and whether anyone will need to read the same events again later. A scheduled batch load runs at fixed intervals and suits daily finance extracts or warehouse models that nobody reads before the next business day. Micro-batch shortens the interval to minutes. Event streaming moves each change as it happens. The choice follows from the latency each downstream use case tolerates, and from whether a failed consumer must be able to rewind and reprocess a window of history. Write these answers down per source before any tool is named, because a 15-minute requirement and a sub-second requirement lead to very different platforms.
In a self-hosted estate, Apache Kafka usually fills the transport role. Its topics keep events for a configured retention period, which lets new consumers start from an earlier offset and lets a failed consumer replay after a fix. Confirm the retention settings, the replication factor and the authentication mechanism (SSL or SASL, as described in the Kafka security documentation) with your platform team, because they determine how much history is recoverable and who can read it. Kafka moves and holds events; it does not schedule transformations or track which model depends on which table. That work belongs to an orchestrator such as Apache Airflow for scheduled runs or Dagster for asset-based runs, which records dependencies, retries and backfills across batch jobs.
Many estates need both. A typical pattern (illustrative) lands Kafka events in object storage or a staging table, then lets Dagster or Airflow run the batch transformations that build reporting models every hour, while a small number of operational alerts consume the stream directly. The decision that matters is which path is the system of record for each dataset. Record that decision explicitly, including who may replay a topic, how orchestrator runs are reconciled against the events they consumed, and which team owns each side of the boundary. Ask any implementation partner to show how replay and backfill were tested on your data volumes before committing to either pattern.
Security requirements: secrets, access and encryption in transit
Pipelines hold credentials for source systems, move regulated data between zones and expose orchestration UIs that can trigger jobs. The six requirements below connect transport security, access control, secret handling and audit evidence, and each one needs a decision recorded before the platform is built.
Client and broker authentication
Kafka clients, brokers and tools authenticate with SSL or SASL. The documented SASL mechanisms are GSSAPI (Kerberos), PLAIN, SCRAM-SHA-256, SCRAM-SHA-512 and OAUTHBEARER. Security is optional in Kafka, so a cluster can run unsecured or mix secured and unsecured listeners. Confirm which mechanism matches your identity provider, that PLAIN is not used without TLS, and that unsecured listeners are closed to producers and consumers outside the pipeline network.
TLS on every listener
Encryption in transit covers client-to-broker, broker-to-broker, Kafka Connect, Airflow metadata database connections, and the connections from Dagster or Airflow workers to sources and warehouses. Kafka encrypts traffic with SSL/TLS, but only where you configure it. Check each listener and inter-broker channel in configuration, confirm certificate issuance and rotation ownership, and test that plaintext ports are not reachable from other network zones.
Authorization and ACL defaults in KRaft
In KRaft clusters the StandardAuthorizer stores ACLs in the cluster metadata log. Resources without ACLs are restricted to super users unless allow.everyone.if.no.acl.found is set to true. Confirm that this setting is false, that super users are a short, named list, and that each topic and consumer group has an explicit ACL owned by a named team. Review the ACL inventory on a fixed schedule.
Secrets storage and rotation
Source credentials, warehouse passwords, API tokens and Kafka client secrets should live in a dedicated secrets store, not in DAG code, Dagster configuration files or connector definitions. Confirm where each secret is stored, who can read it, how rotation is triggered without a pipeline redeploy, and whether intermediate files or logs ever contain credential values. Ask the partner to show a rotation run against a non-production source.
Role-based access to DAGs and assets
Orchestrators control who can view logs, trigger runs, edit schedules and reach source data. Airflow access is governed by its auth manager, and Dagster open source relies on the deployment's own authentication, while role-based access control and SAML SSO are listed as Dagster+ features. Confirm which roles exist, which team owns each DAG or asset group, and whether run triggers and backfills require a separate permission from read access.
Audit logging of access and changes
Auditors will ask who changed a pipeline, who ran a backfill, and who read a secret or a restricted dataset. Confirm that the orchestrator, Kafka and the warehouse each record authentication events, configuration changes and manual triggers, that these logs are shipped to storage outside the pipeline servers, and that retention matches your records policy. Test that a sample change can be traced from request to deployed DAG or asset.
Where sensitive data may flow and how to document it
Start by mapping every personal, regulated or confidential field from source to staging to warehouse before any connector is built. For each field, record the source system, the transformation that touches it, the stage where it lands, the people and service accounts that can read it, and the retention period. Then decide, per stage, whether the field may exist there at all. A common decision is that raw identifiers may sit only in the source-adjacent landing zone, while the warehouse receives pseudonymized or tokenized values. Write these decisions down as a data flow register that the platform team and the data owner both sign, because the register becomes the baseline for every later review.
Intermediate files and logs often leak more than the tables do. Set explicit rules for where staging files, dead-letter queues and temporary extracts may be written, how long they persist, and who can read them. For Airflow, check that task logs, XCom values and rendered templates do not echo payloads, and confirm which fields the scheduler and web UI store in the metadata database. For Kafka, confirm whether topic payloads are encrypted at rest in your storage layer, since TLS protects data only in transit. For Dagster, confirm where run and event log storage lives and whether asset metadata captures sample rows. Test these settings with synthetic records that contain dummy sensitive values, then search the metadata store, logs and object storage for those values.
If any pipeline feeds an AI system, the record-keeping duties in Article 12(1) and the six-month log retention in Article 19(1) of the EU AI Act may apply, but only when the system is high-risk and in scope for that regulation. Confirm applicability with legal counsel before designing log retention, because the answer determines whether pipeline logs must be kept as AI system evidence. Whichever way that question resolves, ask your implementation partner to show how the data flow register, retention rules and metadata checks will be kept as evidence, and who approves changes to them.
Operational requirements and how to verify them
This table lists the operational requirements an orchestrator and streaming platform must meet after go-live, and the test that proves each one works. Read each row as a question to put to a partner or internal team: if the verification step cannot be demonstrated, the requirement is not yet met. The main takeaway is that most failures surface during failover, upgrades and restores, so those should be rehearsed before production.
| Requirement | What to confirm | How to verify |
|---|---|---|
| Metadata database | Airflow runs on PostgreSQL or MySQL in production; SQLite is test-only and MariaDB is not supported as the metadata database | Confirm the backend in configuration, then restart the scheduler and webserver and check that run history and connections persist |
| Scheduler redundancy | More than one Airflow scheduler runs, coordinated through database row-level locks | Stop the active scheduler during a scheduled run and confirm another instance picks up scheduling without duplicate runs |
| Executor choice | Executor matches workload size and isolation needs; hybrid Celery/Kubernetes executors are not supported in Airflow 3.0.0 or later | Run a representative heavy task and a failing task on the chosen executor and review resource limits and retry behavior |
| Version support | Platform runs a version still receiving fixes; Airflow 2 reached end of life on April 22, 2026; Kafka rolling upgrades are supported from the last three releases | Rehearse an upgrade in a non-production copy, including schema migrations, plugin compatibility and rollback |
| Monitoring and alerting | Alerts cover failed runs, missed schedules, consumer lag, broker health and disk growth, routed to a named channel | Inject a failing task and a stalled consumer, then confirm alerts fire and reach the on-call channel within the agreed window |
| Failure handling and on-call ownership | A named owner per pipeline, documented retry rules, and a runbook for reprocessing and backfills | Run a tabletop exercise with a source outage and check who is paged, what is paused and how data is replayed |
| Orchestrator metadata backup | Regular backups of the metadata database and Kafka configuration, stored outside the primary cluster | Restore the backup to a separate environment and confirm DAG run history, connections and topic configuration are intact |
| Kafka security baseline | TLS for client and broker traffic, SASL mechanism selected, and ACLs defined since unset resources are limited to super users | Run a client connection without credentials and confirm it is rejected; review the ACL list against producer and consumer roles |
How to run the checklist with candidate platforms
This sequence turns the requirements checklist into a shortlist and a tested proof of concept, so the choice of orchestrator, streaming layer and connectors rests on evidence from your own sources rather than vendor claims. Each step closes with a written record that a reviewer can check.
Freeze the source and destination inventory
The data owners and platform team list every source system, destination warehouse, file drop and downstream consumer, with the owner, network zone and access method for each. Done means the inventory is signed off by the owners of each system, and any system without a named owner is flagged as an open item. Later steps assume this list is fixed, so changes after this point go through a recorded revision.
Classify data sensitivity for each flow
The security and privacy leads label each source and dataset by sensitivity, personal data, regulated categories and retention obligations, then mark which flows may pass through which network zones and which hosts. The output is a flow register that states, for each pipeline, where sensitive data may land, including staging files, logs and orchestrator metadata. Done means every flow has a classification and a permitted-location statement that the security team has approved.
Set latency and volume targets
The data and business owners agree a freshness target, a maximum acceptable delay and expected daily and peak volumes for each flow, and state which flows truly need streaming and which can run as batch. The record should show the figures in the team's own terms, with the source of each estimate, such as a system report or a vendor's documented limits. Done means each flow has a written target that the proof of concept can measure.
Shortlist orchestrators and streaming options
The platform team scores candidate tools such as Airflow, Dagster, Airbyte, Kafka and NiFi against the checklist, using the supported versions, license terms, deployment models and features you need in your own environment. Confirm each candidate's current release, support window and feature availability in its official documentation, and record any capability you could not verify. Done means a scored comparison with two or three shortlisted options per layer and a list of open questions for each vendor or project.
Run a proof of concept on one real pipeline
The engineering team builds one representative pipeline from a shortlisted tool into the target warehouse, deployed in the intended environment with the planned secrets handling and authentication. The test must include a deliberate schema change, a backfill for a past date range and a forced failure with retry, so you can see how each behaves. Done means the run logs, failure records and timing measurements are captured and compared against the latency and volume targets.
Test lineage, data quality and recovery
The team checks whether lineage is captured automatically or must be maintained by hand, whether data quality checks fail the run or only raise an alert, and how a rerun or backfill affects downstream tables. Include a check that secrets are not written to logs or metadata stores in the default configuration. Done means a short test report that states what each tool did without extra work and what needed custom code.
Record evidence against each requirement
The team maps each checklist requirement to the proof-of-concept result, the configuration, the test log and the named owner who accepted it, and marks any gap as a risk with an owner. The evidence pack is what the security, compliance and architecture reviewers use to approve or reject the design. Done means every requirement has a status of met, partially met or not met, with supporting evidence attached, and the decision record names the selected platforms and the accepted risks.
Questions buyers ask before they write pipeline requirements
What does the requirements work cost, and what drives that cost up?
The requirements work is paid for as discovery time: someone interviews source owners, maps every source and destination, reviews data sensitivity, and writes the document that an engineering team can build against. The price moves with the number of source systems, how many of them lack documentation, how many teams must sign off, and whether a proof of concept is included. Ask for a written scope that lists the sources in scope, the interviews and workshops, the deliverables (requirements document, source inventory, data flow diagram, risk register), and what is excluded, such as building connectors. DeployOpen does not publish a price list, so the quote follows from that scope.
How long do requirements and a proof of concept take?
The duration depends mostly on how many sources must be understood and how quickly the owners of those sources can answer. A narrow pipeline with a few well-documented systems moves much faster than an estate with undocumented databases, legacy file drops and several approval gates. A proof of concept adds time because it needs a target environment, credentials handled under the organization's own controls, and agreed success criteria for latency, volume and data quality. No duration is given here because none was supplied. Ask the partner to state the schedule per phase in the written scope and to name which client dependencies could extend it.
Can our internal team write pipeline requirements without a partner?
Yes, many teams can, provided they have someone who knows the source systems, someone who can model the destination, and someone who understands the security rules that apply to the data. The usual gaps are not technical depth but time and neutrality: internal staff are often also the on-call operators and the source owners, so requirements drift toward what is convenient. A partner adds an outside reviewer who challenges assumptions about freshness, backfills and sensitive fields. If you proceed internally, use the checklist on this page as the outline, and treat any unanswered row as an open risk rather than a detail to settle later.
What does the work need from our own staff?
Three groups of people set the pace. Source owners must confirm what each system contains, how it changes, and how often it can be read. Security staff must approve which fields may leave the source, where credentials are stored, and which networks may carry the data. Platform engineers must agree who receives alerts and who is on call when a scheduled job fails. Ask the partner to name these roles in the scope and to state how many hours per week each role is expected to commit, so that your managers can plan the calendar before the work starts.
Which pipeline requirements should we fix first?
Fix the requirements that change architecture first: the list of sources and destinations, whether each flow is batch or streaming, the latency each consumer needs, and where sensitive data may flow. These decide the orchestrator, the connector choice and the network design. Next, define schema change handling, data quality checks and backfill rules, because they determine how failures are contained. Lineage, monitoring and secrets handling can follow, but they must be decided before production. Ordering this way prevents rework when a late requirement, such as a restriction on personal data, forces a different design.
Does open-source licensing affect which pipeline tools we can choose?
Yes, but the effect depends on how you use the tool. Apache Airflow and Dagster are licensed under Apache-2.0, and Apache Kafka is also under Apache-2.0, with no paid edition from the Apache projects. Dagster's pricing page lists role-based access control, SAML SSO, catalog search, column lineage and audit logs as Dagster+ features rather than part of open-source Dagster, so requirements for those capabilities must be checked against the edition you plan to run. Airbyte's platform repository is under the Elastic License 2.0, which restricts providing the software as a managed service to third parties, and some connectors have their own terms. Confirm each component's license against your intended use before listing it in the requirements.
What should we request in a written scope before signing?
Request a scope that lists each deliverable by name, the sources and destinations covered, the environments involved, the team members and client roles required, the schedule by phase, the assumptions about access and documentation, and the exclusions. Also ask how changes to scope are priced and approved, and which items recur after delivery, such as support or upgrades under a retainer. Confirm how sensitive data will be handled during discovery, including who sees sample records. A clear written scope makes the cost and timeline comparable across proposals.
Compliance evidence to collect during requirements
Decide during requirements which evidence the pipeline must produce, because it is far harder to add later. The core set is run history (every scheduled and manual run, its start and end time, its outcome and the retries behind it), access records (who can view, trigger, edit or read credentials for each DAG, asset or flow), change approvals (who reviewed and merged each change to a DAG, asset definition, connector configuration or NiFi flow, and which version ran in production), and lineage and retention settings (where each dataset came from, what transformed it, and how long raw, staging and warehouse copies are kept). Ask your auditor which of these they will sample, over what period, and in what format. Confirm whether they expect exports from the orchestrator itself or from your ticketing and source control systems, since that choice determines which tools you need to retain and where.
Map each evidence type to a concrete source in your design. Run history usually comes from the orchestrator metadata database, so confirm how long it is retained and whether it is backed up with the rest of the platform. For Airflow, check the authentication and authorization model in the auth manager documentation and confirm which role-based access settings your version supports. For Dagster, the open-source edition does not include the role-based access control, SAML SSO, column lineage or audit log features listed on the Dagster pricing page as Dagster+ features, so decide whether you need them, and if so, whether the managed tier or another control provides them. For Kafka, document the authentication mechanism, the ACL model stored in the KRaft metadata log and whether unauthenticated access is disabled. Record these settings as configuration exports rather than screenshots so they can be re-checked.
DeployOpen prepares controls, configurations and evidence for compliance assessments, but it does not issue audit reports, attestations or certifications. Independent auditors and certification bodies decide what is sufficient, and your own compliance function owns the control framework. If the pipeline feeds AI systems within scope of the EU AI Act, the record-keeping duty in Article 12 of the AI Act and the six-month minimum log retention in Article 19 apply to the logs you keep, so confirm with counsel whether your use is in scope before setting retention periods. Agree the evidence list, its owner and its retention in the written scope before build starts, so the implementation partner can design the logging and export jobs to produce it.
How DeployOpen scopes, delivers and supports pipeline requirements
DeployOpen turns the requirements in this checklist into a written scope covering sources, destinations, latency, orchestration, lineage and secrets before any platform is installed. We then plan, build, test and document the pipelines inside your own cloud accounts, data centers or air-gapped networks, and support them after handover through an optional retainer.
How we scope
- Inventory of source systems, destinations and the data classes each flow carries, including where sensitive data may appear.
- Written record of batch versus streaming needs, volumes, latency targets and failure-handling expectations for each pipeline.
- Fixed-scope agreement listing connectors, orchestrator choice, schema-change handling, quality checks and backfill rules before work starts.
How we build
- Deploy the chosen open-source orchestrator, such as Airflow or Dagster, on PostgreSQL or MySQL metadata storage rather than SQLite.
- Configure connectors, secrets handling, Kafka authentication and authorization, and lineage capture against the scoped requirements.
- Test pipelines, data quality checks and backfill procedures in a non-production environment before any production release.
How we hand over
- Deliver architecture diagrams, runbooks for failure and backfill handling, and a record of connector and version decisions.
- Document where credentials, intermediate files and personal or sensitive data flow, so reviewers can trace each path.
- Walk your operations and data teams through monitoring, alerting, change approval for pipeline code and the upgrade process.
How we support
- Optional retainer covering patching, planned upgrades of orchestrator and Kafka versions, and monitoring of supported release lines.
- Review of new source systems and schema changes against the original checklist, with scope changes agreed in writing.
- Periodic testing of pipeline failure paths and access controls, with findings tracked to closure in your change process.

