DevStudioIT Cloud — hosting and deployment panel for Next.js projects (2026)

TL;DR

DevStudioIT Cloud (devstudioit.cloud) is DevStudio.it's hosting and deployment panel for client projects — not a third-party marketplace, but an in-house operations layer built for the Next.js 15 and Node 22 stack. From one place you manage multiple projects, releases, environment variables, domains, transfer limits, and billing. The data layer runs on Branchly (branchly.cloud) — PostgreSQL and business logic alongside application delivery in the cloud. CI with GitHub Actions builds the artifact and deploys to your hosting — a generic pipeline, not tied to a single PaaS vendor. With the care package (/en/opieka) you get monitoring, backups, and post-launch support.

Who this is for

• Service businesses and software houses that want transparent hosting for Next.js sites — with a panel both clients and developers understand
• Owners of business websites delivered by DevStudio.it who need one place for deploy, domain, and invoicing
• Developers looking for a coherent stack: app on DevStudioIT Cloud, database on Branchly, forms and analytics in production
• Teams planning CI/CD with GitHub Actions — build on Node 22, deploy to the client's hosting, not a black box with no control
• People comparing managed hosting with DIY VPS — and wanting clarity on what the care package actually includes

Keywords (SEO)

devstudioit cloud, nextjs hosting panel, business website deployment, devstudio client hosting, branchly postgresql, production environment variables, github actions deploy hosting, managed care monitoring backup

What DevStudioIT Cloud is — and what it is not

DevStudioIT Cloud is DevStudio.it's operational platform for managing client projects after delivery. It is not another site builder or shared WordPress hosting. The panel focuses on what you actually need day to day in Next.js production:

• Deployments — a new app version reaches production with release history
• Environment variables — per project (DATABASE_URL, API keys, integration URLs)
• Domains — assign the client's domain to the right project
• Limits and transfer — clear usage bands, no invoice surprises
• Payments and billing — billing the business client can understand

On devstudioit.com, the InfrastructureSplit section shows DevStudioIT Cloud next to Branchly — not a marketing slide, but the real split of responsibilities in projects we run. The same panel is linked from the blog sidebar and the care page, because hosting and maintenance are one ecosystem, not a separate service "somewhere else."

Architecture: app in the cloud, data in Branchly

A modern business site or web app is two entities: frontend/API on Node and a persistence layer. DevStudioIT Cloud does not replace the database — it complements Branchly.

Branchly holds PostgreSQL, Prisma migrations, and business data (form leads, CMS content, admin users). DevStudioIT Cloud holds the Next.js runtime: SSR, Server Actions, route handlers, cache, static files after build. The DATABASE_URL from Branchly lands in the Cloud panel as production env — environment changes without digging through code.

Independent scaling, secret rotation in the panel (not in git), and separate audit trails for app hosting vs. database — that is why the DevStudio.it homepage shows both systems as a pair, not competitors.

Panel features — what you see after login

The panel at devstudioit.cloud is designed for many projects at once — a typical agency portfolio of business sites, not one blog on shared hosting.

Multiple projects and release tracking

Each client (or internal product) is a separate project with its own deployment history. You know which version is in production, when the last deploy ran, and whether the merge to main actually reached the server. That fixes the classic problem: "works for the developer, old version in production" — because you see the gap between commit and release.

Environment variables per project

Next.js 15 in production lives on env: DATABASE_URL, NEXT_PUBLIC_*, reCAPTCHA keys, SMTP, webhooks. In DevStudioIT Cloud you set them per project, without SSH file edits on the server. A new API key after rotation = change in the panel + redeploy (or env hot reload, depending on setup) — not hunting .env on three machines.

Rule: the repository never contains production secrets. GitHub Secrets at build time, Cloud panel at runtime — a chain aligned with DevSecOps good practice.

Domains and SSL

A business site without its own domain loses credibility. The panel handles domain assignment to a project — the client ends up on yourcompany.com, not a random developer subdomain. Certificate and routing are part of hosting operations; you focus on DNS at the registrar, infrastructure under DevStudio care handles the rest.

Stats, transfer, and billing

Billing transparency is a sales argument for the care package. The client sees transfer usage, limits, and costs in contract context — not a "sort of free" hosting spreadsheet that surprises you after a year. For you as product owner: stats help decide whether the project needs a larger plan, CDN, or image optimization — before performance hits conversions from Google Ads.

Production stack: Next.js 15 and Node 22

DevStudio.it projects are built on Next.js 15 (App Router, Server Actions, Metadata API) and Node 22 in engines. DevStudioIT Cloud is aligned with that — not legacy PHP or static hosting without SSR.

The panel runs a long-lived Node process for Server Actions, dynamic routes, and multilingual paths (/pl, /en, /de) — not static out/ export only. Prisma migrations run in CI; DATABASE_URL comes from the panel at runtime. When comparing hosts, ask whether they run next start on Node 22 — DevStudioIT Cloud is built for that within our ecosystem.

CI/CD: GitHub Actions → your hosting

The client repo can have a pipeline not tied to one PaaS vendor. The pattern we recommend:

1. Pull request — npm ci, lint, tsc, npm run build (e.g. via scripts/build.cjs with Prisma generate).
2. Merge to main — same build + deploy step to DevStudioIT Cloud (panel API, rsync, or dedicated action — per project integration).
3. Secrets — only in GitHub Secrets and the Cloud panel; never in Action logs.

Key rule: merge nothing that did not pass build in Actions. The Cloud panel is the deploy target, not a substitute for tests. Preview environments can be a separate panel project or branch deploy — policy depends on the contract, but production always has an auditable path.

Example deploy job skeleton (adapt — endpoint and token from the panel):

  deploy:
    needs: quality
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
          cache: 'npm'
      - run: npm ci && npm run build
        env:
          DATABASE_URL: ${{ secrets.DATABASE_URL }}
      - name: Deploy to DevStudioIT Cloud
        run: |
          # upload artifact / panel API call — per-project configuration
          curl -X POST "${{ secrets.CLOUD_DEPLOY_URL }}" \
            -H "Authorization: Bearer ${{ secrets.CLOUD_DEPLOY_TOKEN }}" \
            -F "artifact=@.next/standalone.tar.gz"

This is a generic model: your hosting, your token, your panel project — without dependency on a marketplace with its own config format.

Care package — beyond the panel alone

The panel provides tools. The care package provides accountability after launch: uptime monitoring, backups, incident response, dependency updates within agreed scope. On the care page DevStudioIT Cloud is linked next to Branchly — because maintenance is continuity between app hosting and the data layer.

For a service business that treats the site as a lead channel, downtime in business hours wastes ad spend. Care does not replace the panel — it closes the loop between delivery and the owner's peace of mind.

Typical delivery workflow

Next.js repo (engines.node: "22") → Branchly instance (PostgreSQL, migrations in CI) → DevStudioIT Cloud project (env, transfer limits) → domain and DNS → Actions pipeline (PR = quality, main = deploy) → handover with care (monitoring, panel access). The first release appears in panel history — auditable from day one.

Pre go-live checklist

• Node 22 locally, in CI, and on hosting — matching engines
• DATABASE_URL only in Cloud panel / Secrets — not in repo
• Latest panel release = latest commit on main
• Production domain assigned; HTTP→HTTPS redirects
• Contact form tested on production domain (not localhost)
• Transfer limits and billing plan discussed with client
• Branchly backups + restore procedure in care scope
• Panel access: client team vs DevStudio roles

DevStudioIT Cloud vs "any hosting"

FAQ

Does DevStudioIT Cloud replace Branchly?

No. Cloud hosts the Next.js app; Branchly provides PostgreSQL and data management. In a typical project you use both: DATABASE_URL from Branchly in the Cloud project env. On the DevStudio homepage both products are shown as complementary layers.

How many projects can I have in the panel?

The panel is built for multiple projects — an agency client portfolio or several products for one company. Deploy and transfer limits are per project so billing matches real usage.

Do I have to use GitHub Actions?

No — deploy can be manual by the DevStudio team under care. We recommend Actions because it audits: the same build in PR and production. It is generic CI targeting your panel hosting, not a closed format from one vendor.

What if I exceed the transfer limit?

Panel stats show usage early. Before exceeding, discuss plan upgrade or optimization (images, cache, CDN) — in the care package DevStudio monitors performance and can suggest actions before campaign traffic hits limits.

Is the panel available to the end client?

Yes — transparent billing and project visibility build trust. Permission scope (read-only stats vs full env access) is set at delivery. Sensitive secrets stay with technical roles.

Summary

DevStudioIT Cloud is DevStudio.it's own hosting and deployment panel — multiple projects, releases, env, domains, stats, and billing in one place. Together with Branchly (data) and the care package (monitoring, backups) it forms the full chain from commit to stable production on Next.js 15 and Node 22. CI via GitHub Actions builds the artifact and deploys to panel hosting — without dependency on someone else's marketplace. If you want hosting "for the client," with a panel business and tech teams understand, start at devstudioit.cloud.

Want hosting for your Next.js project?

• Open DevStudioIT Cloud — projects, deployments, and billing panel
• Contact us — we'll match infrastructure, Branchly, and your CI pipeline
• Care package — monitoring, backups, and post-launch support