GitLab

FlutterFlow's GitHub integration is the only supported way to get your project code out of the browser editor and into a Git host. Open your FlutterFlow project and navigate to Settings (gear icon) → Integrations → GitHub. Click Connect GitHub, which opens an OAuth authorization flow — approve access for your GitHub account or organization. After authorization, FlutterFlow asks you to choose a repository: you can let FlutterFlow create a new repo, or select an existing empty one. For a GitLab mirror setup, create a dedicated GitHub repo like `my-app-flutterflow` so it has a clear purpose. Once connected, click Push to GitHub (the GitHub icon in the top toolbar will now be active). FlutterFlow generates the entire Flutter project — all Dart files, pubspec.yaml, platform folders — and commits it to the `main` branch of your GitHub repository. This initial commit is the foundation the GitLab mirror will pull from. Verify the push worked by opening your GitHub repository in a browser: you should see a standard Flutter project structure with lib/, android/, ios/, web/, and pubspec.yaml at the root. Going forward, every time you make changes in FlutterFlow and click the Push to GitHub button, a new commit appears in this repository.

Log into GitLab (gitlab.com or your self-hosted instance) and create a new blank project with any name — for example, `my-app-gitlab`. Do not initialize it with a README since the mirror will provide all content. Once the blank project is created, open the project's left sidebar and navigate to Settings → Repository. Scroll down to the Mirroring repositories section and click Expand. Click the Add new mirror button (the label may say 'Add a mirror' depending on your GitLab version). In the Git repository URL field, paste the HTTPS clone URL of your GitHub repository — it looks like `https://github.com/your-username/my-app-flutterflow.git`. Set the Mirror direction to Pull (GitLab pulls FROM GitHub). If your GitHub repository is private — which it should be, since FlutterFlow commits your entire app code — you need to authenticate: in the Authentication section, select Personal access token and paste a GitHub Personal Access Token (PAT) with at least repo read scope. You can generate a PAT in GitHub → Settings → Developer Settings → Personal access tokens → Fine-grained tokens. Check the box for Mirror only protected branches if you want to limit what syncs. Click the Save button. GitLab will immediately attempt an initial mirror sync — you can click the refresh icon next to the mirror entry to trigger it manually. After a minute, refresh your GitLab project's repository view: you should see the same Flutter project files that are in GitHub.

If your GitHub repository is public you can skip this step, but a private repository is strongly recommended since your Flutter source code may contain logic you don't want exposed. The GitLab mirror needs read access to your GitHub repo. In GitHub, go to your account avatar in the top-right → Settings → Developer settings → Personal access tokens → Fine-grained tokens → Generate new token. Give it a descriptive name like "GitLab mirror for FlutterFlow app." Set the Expiration to a reasonable period (90 days or 1 year, then set a calendar reminder to rotate it). Under Repository access, select Only select repositories and choose the specific FlutterFlow GitHub repo. Under Permissions, grant Contents: Read-only — this is the minimum required for mirroring. Click Generate token and copy it immediately (it won't be shown again). Go back to your GitLab project → Settings → Repository → Mirroring repositories, click Edit on the mirror you created, and paste the token in the Password or Token field. Save. Test by clicking the sync icon — if the mirror shows a green checkmark, authentication is working. If it shows a red error, double-check that the PAT has access to the correct repository and that you copied it without extra spaces.

Now that GitLab has your Flutter project via the mirror, you can run CI/CD pipelines on it. Create a file called `.gitlab-ci.yml` at the root of your GitLab repository. The key challenge for Flutter CI on GitLab is that the default runner images don't include the Flutter SDK — you need to specify a Docker image that has Flutter pre-installed. The most commonly used image is `ghcr.io/cirruslabs/flutter:stable` (published by Cirrus CI and widely used in the community). Your pipeline needs at least two jobs: a test job that runs `flutter test` to validate the app, and optionally a build job that compiles `flutter build web --release` or `flutter build apk --release`. Keep secrets (signing keystores, API keys) in GitLab CI/CD variables (Settings → CI/CD → Variables) — never commit them to the repository. Reference them in the pipeline as `$VARIABLE_NAME`. The pipeline triggers automatically on every commit that the mirror syncs from GitHub, which means every FlutterFlow export that triggers a Push to GitHub will also trigger your GitLab CI pipeline within minutes.

1# .gitlab-ci.yml — Flutter CI pipeline for a FlutterFlow-exported project
2
3image: ghcr.io/cirruslabs/flutter:stable
4
5stages:
6  - test
7  - build
8
9# Cache pub packages between pipeline runs to speed up jobs
10cache:
11  key: "flutter-pub-cache"
12  paths:
13    - .pub-cache/
14
15variables:
16  PUB_CACHE: "$CI_PROJECT_DIR/.pub-cache"
17
18before_script:
19  - flutter --version
20  - flutter pub get
21
22flutter_test:
23  stage: test
24  script:
25    - flutter analyze
26    - flutter test --coverage
27  artifacts:
28    when: always
29    reports:
30      coverage_report:
31        coverage_format: cobertura
32        path: coverage/cobertura.xml
33
34build_web:
35  stage: build
36  script:
37    - flutter build web --release
38  artifacts:
39    paths:
40      - build/web/
41    expire_in: 1 week
42  only:
43    - main

Test the complete pipeline by making a visible change in FlutterFlow — for example, changing a text label on one of your screens — then clicking the Push to GitHub button in FlutterFlow. Wait up to 5 minutes for GitLab's mirror polling interval to pick up the new commit (or click the sync icon in GitLab → Settings → Repository → Mirroring repositories to trigger an immediate sync). Once the commit appears in your GitLab project's repository, navigate to CI/CD → Pipelines — you should see a new pipeline triggered by the mirrored commit. Click into the pipeline to watch the individual jobs run: the test job will run `flutter analyze` and `flutter test`, and the build job will compile the web artifact. If everything is green, the integration is fully working. To stay informed about pipeline results, set up GitLab email notifications: go to your GitLab account → Notifications and set the notification level for this project to only failed pipelines (so you get alerted when a FlutterFlow export breaks a test, without getting spammed on every successful run). You can also connect GitLab to Slack via Settings → Integrations → Slack Notifications for team-wide alerts.