Code Editor | Unlock Full Data Transformation Power Without Leaving Governance

While Edilitics’ no-code operations solve 90% of data preparation needs, real-world edge cases demand more.
That’s where the inbuilt Code Editor comes in—giving you full Python scripting capability inside the same governed, auditable workflows.

With access to high-performance libraries like Polars, NumPy, SciPy, and Regex (re), the Edilitics Code Editor enables you to tackle:

  • Advanced transformations

  • Complex calculations

  • Scientific modeling

  • Deep pattern matching

—without ever sacrificing governance, auditability, or scheduling control.

Why Advanced Workflows Need a Code Editor

No-code handles the common paths.
But when you hit:

  • ✅ Complex multi-condition filters
  • ✅ Recursive or cumulative aggregations
  • ✅ Scientific computing and optimizations
  • ✅ Deep text cleansing with regex
  • ✅ Dynamic column creation and logic branching

—prebuilt operations aren’t enough.

Without scripting ability, you'd be forced out of governance-safe pipelines—creating manual gaps and risk.

Edilitics eliminates that by embedding full scripting within the no-code ecosystem.

Supported Languages and Libraries

Inside the Edilitics Code Editor, you can leverage:

LibraryPurpose
PolarsHigh-speed DataFrame transformations
NumPyNumerical computing and array manipulation
SciPyScientific modeling, optimization, and statistical functions
MathCore mathematical operations
Regex (re)Advanced text extraction, cleaning, pattern matching
Python 3.xThe engine enabling dynamic, complex transformations

All libraries are sandboxed, performance-optimized, and auditable inside Edilitics workflows.

Key Features of the Edilitics Code Editor

FeatureBenefit
Syntax HighlightingClearer, easier-to-debug code authoring
Inline Error CheckingCatch mistakes before impacting production runs
AutocompleteFaster, more accurate script writing
Theme CustomizationLight/dark modes for user comfort
Run/Test ValidationPre-execution script testing without full commit
Script ReuseSave and reuse validated scripts across transformations

Every script runs within the governed transformation pipeline—not as external, ad-hoc code.

How to Use the Code Editor in a Workflow

  1. Insert a "Custom Code" Step

    Add a scripting step within your no-code transformation sequence at any point.

📌 Custom code and no-code operations can be combined freely in the same workflow, executed in the order you define.

  1. Author or Paste Python Code

    Write your transformation logic using supported libraries (Polars, NumPy, SciPy, re).

    Code steps can operate on outputs from prior no-code steps—or prepare outputs for upcoming no-code operations.

  2. Run/Test for Validation

    Validate your script against sample data without committing to production runs.

    Preview how your code modifies the dataset before integrating it into the full transformation pipeline.

  3. Save and Integrate into the Flow

    Once validated, the script becomes a native, governed operation:

    • Version-tracked

    • Audited

    • Scheduled and fail-safe protected (just like no-code steps)

📌 Hybrid Flows Supported:

Mix any number of code and no-code steps — Edilitics automatically handles execution order, schema validation, and operational integrity across the full hybrid workflow.

Example Advanced Applications

ScenarioExample Outcome
Multi-conditional value mappingClassify rows based on dynamic business rules
Running totals across partitionsCumulative sales, moving averages
Regex-driven email domain extractionExtract domain names from customer emails
Statistical scoringCompute weighted KPIs for ML features
Dynamic schema creationAdd columns programmatically based on patterns

Sample Polars Examples

Complex If-Else Logic


import polars as pl
def transform(df: pl.DataFrame) -> pl.DataFrame:
df = df.with_columns(
pl.when((pl.col("sales") > 10000) & (pl.col("returns") < 50))
.then("High Performer")
.otherwise("Standard")
.alias("performance_label")
)
return df

Regex-Based Pattern Matching


import polars as pl
import re
def transform(df: pl.DataFrame) -> pl.DataFrame:
df = df.with_columns(
pl.col("email").apply(lambda x: re.match(r'.+@(.+)', x).group(1) if x else None).alias("email_domain")
)
return df

Both examples stay fully inside Edilitics' governed runtime—no external hacking, no loss of auditability.

Best Practices for Maximum Efficiency

  • Test scripts using Run/Test before full deployment

  • Write modular code for flexibility and reuse

  • Trust autocomplete and syntax checks to reduce errors

  • Chain code and no-code for hybrid pipelines where needed

Enterprise-Grade Control Without Compromise

The Edilitics Code Editor is built for:

  • ✅ Full governance and audit logging across all custom scripts

  • ✅ Seamless scheduling, error handling, and rollback integration

  • ✅ Schema validation even post-script execution

You retain complete flexibility—without breaking the trust boundaries enterprise data demands.

Next: Chain Power with Simplicity

Pair code-based operations with:

—creating hybrid transformation pipelines built for scale, speed, and governance.

The Edilitics Inbuilt Code Editor unlocks the final 10% of data transformation power that no-code alone cannot reach—with no loss of traceability, auditability, or operational control.

Welcome to truly governed, extensible, enterprise-ready data workflows.

Enterprise Support & Technical Assistance

For technical inquiries, implementation support, or enterprise-level assistance, our dedicated technical support team is available to ensure optimal deployment and utilization of Edilitics solutions. Please contact our enterprise support desk at support@edilitics.com. Our team of specialists will respond promptly to address your requirements.

« Cast Data Types

Column Aggregations »

Unify Data. Automate Workflows. Accelerate Insights.

Eliminate silos, automate workflows, and turn raw data into business intelligence - all in one no-code platform.