Introduction
Build CI Pipelines Without Writing YAML
PipeStudio is a visual pipeline builder that lets you create, configure, simulate, and export CI pipelines through an intuitive interface. Generate GitLab CI or GitHub Actions config from one project definition.
Core workflow
Create
Answer wizard questions or compose blocks on the drag-and-drop canvas.
Simulate
Run the pipeline on PipeStudio with streamed logs before touching CI.
Export
Generate versioned GitLab or GitHub config and commit to your repo.
Who it's for
- Developers
Save hours creating and managing pipelines. Focus on code, not configuration.
- DevOps teams
Standardize pipeline creation across your team with reusable templates and best practices.
Get up and running with PipeStudio in four steps — matching the create → simulate → export workflow.
Create your account
Sign up with email, Google, or GitHub — or join the waitlist while PipeStudio is in development.
Available sign-up methods
- Email and password
- Google account (OAuth)
- GitHub account (OAuth)
- Waitlist at /signup (pre-launch)
Build your project definition
Use the guided wizard or drag-and-drop canvas. Both paths produce the same project definition.
What you'll configure
- Repository URL and CI platform (GitLab or GitHub)
- Language, framework, stages, build, and test settings
- See Wizard vs Canvas if you're unsure which path to pick
Simulate on PipeStudio
Run your pipeline in-platform before exporting. Stream logs, inspect block output, and fix issues while context is fresh.
Learn more
- See Pipeline Simulation for the full workflow
- Confirm stages pass before committing config to CI
Export and commit
Generate platform-specific config, review output, and commit to your repository.
You can
- Download YAML for GitLab CI or GitHub Actions
- Save your pipeline for future reference
- Track changes in Git via pull request — see Versioned Configs
Common outcomes teams achieve with PipeStudio.
- First pipeline in minutes
Answer wizard questions about your repo and stack — or skip to the canvas when you already know your CI shape. Generate a reviewable pipeline from a clear project definition instead of a blank config file.
- Ship CI with confidence
Run the pipeline on PipeStudio before anything reaches GitLab or GitHub. Fix broken stages early with streamed logs and block-level output, then commit only when the run looks right.
- One definition, both platforms
Keep a single project definition and export GitLab CI or GitHub Actions config when you're ready. Switch platforms without rebuilding from scratch.
Everything PipeStudio includes to design, validate, and export production-ready pipelines.
- 9-step pipeline wizard
Walk through project basics, pipeline structure, runners, build, testing, notifications, advanced options, review, and generation.
- Visual pipeline editor (canvas)
Drag and drop stages and jobs, connect dependencies, and preview config updates in real time. Switch between wizard and canvas on the same project.
- In-platform pipeline simulation
Run the full pipeline flow inside PipeStudio. Stream logs per block, confirm stages pass, and iterate without burning CI minutes.
- AI pipeline generation
Turn wizard answers or canvas layouts into GitLab CI or GitHub Actions config. Preview, simulate, edit, and regenerate as your project evolves.
- AI-powered suggestions
Get recommendations for security, performance, testing strategy, and platform-specific best practices.
- Multi-platform support
Generate GitLab CI and GitHub Actions pipelines from the same project definition.
- Real-time validation
Receive immediate feedback on required fields, syntax, security, and configuration issues while you build.
- Versioned project configs
Commit generated config to Git for review in pull requests. Promote changes through branches with a clear audit trail.
- File management
Save pipeline definitions, download exports, and manage your pipeline library in one place.
Both paths build the same project definition. Pick the approach that fits how you like to work.
| Guided wizard | Drag-and-drop canvas | |
|---|---|---|
| Best for | Step-by-step questions about repo, stack, and stages | Hands-on control over every block and value |
| Input style | Forms, dropdowns, toggles | Visual blocks, inline params, edges |
| Learning curve | Lower — prompts guide you | Higher — more flexibility, more decisions |
| Output | Same project definition | Same project definition |
| Switching | Open canvas from the same project | Open wizard from the same project |
When to use the wizard
- You're new to CI or want guided questions about repo, language, stages, and tests
- You want defaults suggested from your repository and stack
- You prefer a checklist-style flow with validation at each step
When to use the canvas
- You already know your pipeline shape and want full control
- You need to fine-tune every command, param, and dependency
- You want to compose lint, test, build, and deploy blocks visually
The wizard guides you through creating a complete CI pipeline in nine steps.
Project & repo basics
Provide your repository URL, choose GitLab or GitHub, and configure language and framework.
Pipeline structure
Define stages and jobs — the skeleton of your pipeline from lint through deploy.
Execution mapping
Map jobs to runners or agents, including labels, environments, and execution targets.
Build configuration
Define build commands, caching, environment variables, and artifact management.
Testing & security
Configure tests, coverage, security scans, and linting tools.
Notifications
Set up Slack, Discord, email, or custom webhook notifications.
Advanced options
Configure matrix builds, schedules, manual approvals, and timeouts.
Review
Confirm your complete configuration before generation.
Generate pipeline
Generate GitLab CI or GitHub Actions config and download when ready.
For field-level detail on every step, see Wizard Field Reference.
Condensed reference for wizard steps, required fields, and known gaps. Sourced from the full wizard field inventory.
Step 0 — Project & Repo Basics
Required to proceed: repositoryUrl, projectName, language, branches (≥1)
- CI platform: GitHub Actions or GitLab CI
- Repository URL, project name, description
- Language, framework, runtime version, package manager
- Build system, monorepo/subdirectory, linter
- Target environments, deployment type, secrets
Step 1 — Pipeline Structure
Required to proceed: stageOrder (≥1 stage), branchStages
- Stage order (lint, test, build, deploy, etc.)
- Jobs per stage and branch-specific stage rules
- Per-branch deployment enablement
Step 2 — Execution Mapping
Required to proceed: Default runner OR custom runners + job assignments
- Runner labels and tags
- Job-to-runner assignments
- Environment mapping per job
Conditional — required when not using default runner.
Step 3 — Build Configuration
Required to proceed: Valid build method and method-specific fields
- Build method: runtime, dockerfile, makefile, custom
- Build/install commands, output directory, caching
- Dockerfile path, build args, target stage
- Artifacts and environment variables
Step 4 — Testing & Security
Required to proceed: At least one of: runTests, runLint, sast, securityScan
- Test, coverage, lint, and SAST toggles
- Security tools: Trivy, npm audit, Bandit, Snyk, OWASP ZAP
- Per-tool configuration options
Step 5 — Notifications
Required to proceed: Optional (skippable)
- Enable notifications toggle
- Notify on: success, failure, both, or manual
- Slack, Discord, email, or custom webhook URLs
If enabled, at least one notification channel is required.
Step 6 — Advanced Options
Required to proceed: Optional
- Matrix builds and runtime versions
- Manual approval, scheduled pipelines (CRON)
- Timeout, interruptible, allow failure
- GitHub matrix JSON; GitLab child pipelines
Step 7 — Review
Required to proceed: Read-only
- Summary of all prior steps with edit shortcuts
- Validation errors and AI generation status
Step 8 — Generate Pipeline
Required to proceed: Must generate pipeline to finish
- Generate with AI (default on)
- Optimize, download, copy, save to account
Known gaps (not in current wizard flow)
| Item | Status |
|---|---|
| DeploymentStep | Full UI exists but not mounted in wizard flow |
| PresetSelector | Imported in Step 0 but not rendered |
| securityScan toggle | In schema; counted in validation but no UI toggle |
| deployEnvironments | In schema; no UI on Pipeline Structure |
Build pipelines visually with drag-and-drop. No YAML knowledge required.
Add stages
Click the "+" button to add a stage. Stages run in sequence and group related jobs.
Add jobs
Drag job templates into stages and configure commands, environment, and dependencies.
Connect jobs
Define dependencies with edges so jobs run only after prerequisites succeed.
Preview config
Watch your pipeline config update in real time, then export when ready.
Run your pipeline on PipeStudio before it touches GitLab or GitHub.
What simulation does
In-platform simulation executes your project definition inside PipeStudio. You see real-time logs, block-level pass/fail status, and stage progression without consuming CI minutes or pushing config to your repository.
How to start a simulation
Build your project definition
Complete the pipeline wizard or compose blocks on the visual editor canvas.
Open the simulation view
From your project dashboard at launch, click "Simulate" to run against your current configuration.
Review results
Watch logs stream block-by-block. Inspect stdout, stderr, and exit codes before exporting.
What you see during a run
- Streamed logs
Live log output per block and stage.
- Pass/fail indicators
Each block shows success or failure as the run progresses.
- Stage timeline
Visual timeline of stages and job dependencies.
Recommended workflow
Simulate your pipeline on PipeStudio
Fix configuration issues based on logs and validation feedback
Re-simulate until all stages pass
Export GitLab CI or GitHub Actions config to your repo
PipeStudio validates your configuration as you build and before generation.
Per-step wizard validation
| Step | Rule |
|---|---|
| 0 — Basics | repositoryUrl, projectName, language, branches.length > 0 |
| 1 — Structure | branches.length > 0, stageOrder.length > 0 |
| 2 — Runners | useDefaultRunner OR (runners exist AND jobAssignments.length > 0) |
| 3 — Build | Valid for selected buildMethod (runtime, dockerfile, etc.) |
| 4 — Testing | runTests OR runLint OR sast OR securityScan |
| 5–8 | Optional, review, or generate — no blocking validation |
At generation time
- Syntax checks on generated YAML output
- Security and best-practice recommendations via AI
- Missing required fields surfaced on the Review step
- Platform-specific conventions for GitLab CI and GitHub Actions
Simulation as deeper validation
Validation catches structural and syntax issues early. Simulation goes further by executing your pipeline flow in-platform so you can confirm stages behave as expected before committing config. See Pipeline Simulation.
Turn wizard answers or canvas layouts into reviewable GitLab CI or GitHub Actions config.
How it works
Provide project context
Wizard answers or canvas block layout define your repo, stack, stages, build, and test setup.
Generate with AI
PipeStudio uses AI (enabled by default) to produce platform-specific config matching your project definition.
Preview and iterate
Review generated output, simulate the pipeline, adjust your definition, and regenerate as needed.
Export
Download or copy `.gitlab-ci.yml` or workflow YAML and commit to your repository.
Distinct from AI suggestions
AI pipeline generation produces your full config file. AI suggestions (see AI Suggestions) recommend improvements to security, performance, and best practices — they do not replace generation.
Recommendations to improve performance, security, and maintainability.
- Security recommendations
Security scans, dependency checks, and secret detection.
- Performance optimization
Caching strategies, parallel jobs, and build-time reduction.
- Best practices
Industry-standard patterns for your stack and pipeline layout.
- Testing strategies
Unit, integration, and E2E testing recommendations.
Languages, frameworks, and deployment options available in the wizard.
| Language | Frameworks | Versions | Package managers |
|---|---|---|---|
| Java | Spring Boot, Quarkus, Micronaut, Jakarta EE | 8, 11, 17, 21 | Maven, Gradle |
| Python | Django, Flask, FastAPI, Tornado, Pyramid | 3.8 – 3.12 | pip, pipenv, poetry |
| Go | Gin, Echo, Fiber, Chi, Revel | 1.18 – 1.23 | Go Modules |
| Rust | Actix Web, Rocket, Axum, Warp, Tide | 1.70 – 1.75 | Cargo |
| .NET | ASP.NET Core, Blazor, MAUI, EF Core | 6, 7, 8 | NuGet |
| JavaScript | React, Next.js, Vue, Angular, Svelte | 16, 18, 20, 22 | npm, yarn, pnpm |
| Ruby | Rails, Sinatra, Hanami, Grape | 2.7 – 3.3 | Bundler |
| PHP | Laravel, Symfony, CodeIgniter, Slim, Yii | 7.4 – 8.3 | Composer |
Deployment types
- Docker
- Serverless
- Bare Metal
- Static Hosting
Target environments
- development
- staging
- production
- testing
- preview
- other
Paste existing YAML into the visual editor to import and modify pipelines.
How to import
Open the visual editor
From your project dashboard, open an existing project or create a new one and switch to the canvas.
Paste your config
Paste GitLab CI YAML or GitHub Actions workflow YAML into the import panel.
Review the visual representation
PipeStudio parses the config and converts it to stages, jobs, and dependencies on the canvas.
Edit and re-export
Adjust blocks, simulate, and regenerate config for any supported platform.
Keep pipeline definitions structured, reviewable, and auditable in Git.
Workflow
Generate from one project definition
Wizard or canvas produces GitLab CI or GitHub Actions config.
Review in a pull request
Commit generated config to your repo and review changes alongside application code.
Promote through branches
Merge pipeline updates through your normal Git workflow — main, develop, release branches.
Maintain an audit trail
Every pipeline change is versioned in Git with a clear history of who changed what and when.
When your pipeline is ready, export platform-specific config for manual deployment.
Download config
Download generated config and commit it to your GitLab or GitHub repository. See Versioned Configs for the recommended Git workflow.
Save for later
Save your pipeline configuration to your account for future reference or as a reusable template.
Import existing config
Already have a pipeline? See Import Existing Pipelines.
Secure access with multiple sign-in options.
- Email & password
Create an account with your email. Verify with the OTP code or confirmation link we send.
- Google OAuth
Sign in with Google. We only access basic profile information with your permission.
- GitHub OAuth
Connect GitHub to access repositories and validate pipeline configurations.
Your hub for pipeline projects at launch — create, simulate, export, and manage saved work.
What you can do from the dashboard
- View all pipeline projects
- Start a new pipeline via "Start New Pipeline"
- Open the guided wizard or drag-and-drop canvas for any project
- Run in-platform simulation and view run history
- Export GitLab CI or GitHub Actions config
- Access saved files and generated exports
Typical flow
Create or open a project
Build with wizard or canvas
Simulate and review logs
Export and download config
Manage account settings, preferences, and saved pipelines.
Settings
Manage your profile, account, security, and preferences from the dashboard settings area. You can update your display name and avatar, change email or password, review active sessions, export account data, and configure notification preferences.
Access saved pipeline configurations and generated exports from your dashboard.
Managing your files
Pipeline configurations and generated files are stored securely in your account. From the dashboard you can:
- View all saved pipelines
- Download YAML exports
- Edit and regenerate configurations
- Delete files you no longer need
Planned capabilities beyond the core create → simulate → export workflow.
- Team workspaces
Shared workspaces for teams to collaborate on pipeline definitions. Coming in a future release.
- Sharing & collaboration
Share projects with teammates, comment on pipeline changes, and co-edit configurations.
- Billing & plans
Free tier at launch with premium features such as advanced AI, team collaboration, and priority support.
- Enterprise
SSO/SAML, audit logs, and VPC or on-prem deployment options for larger organizations.
GitLab CI Integration
Generate `.gitlab-ci.yml` files for manual deployment to GitLab.
Setup checklist
Optionally provide a Personal Access Token to validate repository access. Commit the generated YAML to your repository.
Select GitLab CI in the wizard or project settings
Generate your pipeline YAML using the wizard or canvas
Download the generated `.gitlab-ci.yml` file
Commit the file to your GitLab repository
GitHub Actions Integration
Generate workflow YAML for GitHub Actions.
Setup checklist
Download workflow YAML and commit it to your repository's `.github/workflows/` directory.
Select GitHub Actions in the wizard or project settings
Sign in with GitHub OAuth for easy setup
Or create a token at GitHub → Settings → Developer settings with `repo` scope
Commit workflow YAML to `.github/workflows/`
Common questions about using PipeStudio.
How do I create a pipeline in PipeStudio?
Start with a guided wizard or a drag-and-drop canvas. Both paths build the same project definition — define your pipeline, simulate it on the platform, then export GitLab CI or GitHub Actions config when you are ready.
When should I use the wizard vs the drag-and-drop builder?
Use the wizard when you want step-by-step questions about your repo, language, stages, tests, and deploy targets. Use the canvas when you want full control — compose blocks and edit configs, params, and values directly. See Wizard vs Canvas.
How does AI pipeline generation work?
PipeStudio turns your wizard answers or canvas layout into reviewable GitLab CI or GitHub Actions config. Inspect the output, adjust your project definition if needed, simulate again, then commit the config to your repo. See AI Pipeline Generation.
Can I test a pipeline before pushing to my repo?
Yes. PipeStudio simulates runs on the platform so you can stream logs, inspect block output, and fix issues before the config lands in GitLab or GitHub. See Pipeline Simulation.
Can I store pipeline definitions in Git?
Yes. Generate config from your project definition, review the output, commit it to your repo, and run it on your CI provider. See Versioned Configs.
What platforms are supported?
GitLab CI and GitHub Actions. Choose your platform in the wizard or project settings and PipeStudio generates the matching config format from the same project definition.
What types of pipelines can I create?
Pipelines for any programming language and framework supported in the wizard — including Node.js, Python, Java, .NET, Go, Rust, Ruby, PHP, and Docker-based workflows.
Do I need to know YAML to use PipeStudio?
No. PipeStudio is visual-first. Advanced users can edit generated YAML output directly, or import existing config via the visual editor.
Is PipeStudio free to use?
Yes — PipeStudio is free. The product is currently in development; join the waitlist at /signup and we'll email you when it's ready. Premium features are planned for the future.
Is my data secure?
Yes. Data is encrypted in transit and at rest. Repository credentials are stored securely and never exposed to third parties. See Security.
Can I import my existing pipelines?
Yes. Paste existing YAML into the visual editor. See Import Existing Pipelines.
Common issues and how to resolve them.
Pipeline won't generate
If pipeline generation fails, check the following:
- Verify all required wizard steps are completed
- Ensure all required fields are filled correctly
- Check that your project configuration is valid
- Review validation errors on the Review step
Generated config has errors
If validation errors appear in your generated config:
- Review error messages and fix missing required fields
- Ensure environment variables are properly quoted
- Check that image names and paths are valid
- Re-generate after fixing the project definition
Simulation fails or blocks don't pass
If in-platform simulation fails:
- Inspect streamed logs for the first failing block
- Verify build commands, test commands, and image references
- Confirm runner/agent mapping matches your intended environment
- Fix the project definition and re-simulate before exporting
Import doesn't parse correctly
If pasted YAML doesn't import as expected:
- Check for platform-specific syntax (matrix, child pipelines, custom DSL)
- Simplify complex sections and re-import in smaller pieces
- Manually adjust blocks on the canvas after import
- Validate with simulation before re-exporting
Can't save files
If you cannot save your pipeline configuration:
- Refresh the page and try again
- Clear your browser cache and cookies
- Ensure you're logged in with a verified account
Need help? Reach out through any of the channels below.
Email support
Send us an email for technical support or product questions.
GitHub issues
Report bugs or request features on our GitHub repository.
Community & launch updates
Join the waitlist to get updates and connect with other users.
Privacy Policy
Overview
PipeStudio respects your privacy. This policy describes what data we collect, how we use it, and your rights. A full policy will be published before public launch.
Data we collect
- Waitlist email addresses when you sign up for launch notifications
- Account information when you register (email, OAuth profile basics)
- Pipeline project definitions and generated config you create in PipeStudio
- Usage data to improve the product (pages visited, features used)
How we use your data
- Provide and improve the PipeStudio service
- Send launch updates and product notifications (you can unsubscribe)
- Generate AI-powered pipeline YAML from wizard answers
- Secure your account and prevent abuse
Third parties
We use OpenAI only for AI pipeline YAML generation. OAuth providers (Google, GitHub) handle authentication. We do not sell your data to third parties.
Contact
Privacy questions: sudopeyman@gmail.com
Terms of Service
Agreement
By using PipeStudio you agree to these terms. A complete terms of service will be published before public launch.
Service availability
PipeStudio is currently in development. Features, availability, and pricing may change. We provide the service on an "as is" basis during beta and pre-launch periods.
Acceptable use
- Do not use PipeStudio for unlawful purposes
- Do not attempt to access other users' data or accounts
- Do not abuse AI generation or platform resources
- Do not upload malicious code or credentials in pipeline definitions
Limitation of liability
PipeStudio generates CI configuration as a tool. You are responsible for reviewing generated config before deploying to production systems. We are not liable for pipeline failures, data loss, or downtime in your CI environment.
Security
Data protection
All data is encrypted in transit (TLS) and at rest. We follow industry-standard security practices for authentication, storage, and access control.
Credentials
Repository credentials and tokens are stored securely and never exposed in generated config or logs. OAuth tokens are scoped to minimum required permissions.
Enterprise features (planned)
- SSO / SAML authentication
- Audit logs for team activity
- VPC and on-prem deployment options
- Vulnerability disclosure program
Report a security issue
Contact sudopeyman@gmail.com to report security concerns.
