$272,670top of the range in California · middle $135,980 / yr
AI is transforming this role
Low Code Developers in the United States earn a median of $135,980 a year. Pay starts near $82,460. Pay reaches $272,670 at the top of the range in California, the best-paying state for this work among those with at least 500 people in the job.
Source: U.S. Bureau of Labor Statistics, Occupational Employment and Wage Statistics, May 2025 (Software Developers, SOC 15-1252). Last checked 9 September 2026.
Entry level
$82,460
Top of the range · California
$272,670
Education
Bachelor's degree in CS or IT
Wages — U.S. Bureau of Labor Statistics, Occupational Employment and Wage Statistics, May 2025 (Software Developers). Top of the range is the highest state-level figure among states with at least 500 people in the job. AI-impact rating is PayCrunch's editorial assessment. Updated September 2026.
🆕 New & Trending AI Tools for Low Code DeveloperReviewed September 2026
We track new AI-tool launches every week and refresh this list — here’s what’s gaining traction for Low Code Developer work right now.
Claude CodeNEWFree / usage-based
Terminal coding agent that reads your repo, runs tests, and ships multi-file changes.
How a Low Code Developer uses it: describe a feature and let it implement and test it across the codebase
OpenAI CodexNEWIncl. w/ ChatGPT plans
Agent that runs longer, deterministic multi-step coding jobs on its own.
How a Low Code Developer uses it: delegate a well-defined build or migration and review the finished result
WindsurfNEWFree / $15 mo
Agentic IDE that keeps context across a whole project.
How a Low Code Developer uses it: make large, coordinated changes without losing track of the codebase
AWS KiroNEWPreview / see site
Spec-driven coding agent that turns written specs into working code.
How a Low Code Developer uses it: write the spec first and let it build to that spec
NotebookLMNEWFree / $7.99 mo
Google tool that answers questions grounded only in the documents you give it — with citations.
How a Low Code Developer uses it: load your own manuals, policies, or PDFs and ask questions that stay accurate to the source
CursorFree / $20 mo
AI-native code editor that edits across an entire project.
How a Low Code Developer uses it: describe a change in plain English and let it rewrite and refactor whole files
GitHub Copilot (Agent Mode)$10–19 mo
AI pair-programmer built into VS Code and GitHub that now completes multi-step tasks.
How a Low Code Developer uses it: hand off a task and have it plan, edit multiple files, and open a pull request
ChatGPTFree / $20 mo
The most-used AI assistant — writing, analysis, research, and images from a plain-language chat.
How a Low Code Developer uses it: draft emails and documents, summarize long files, and get instant answers to on-the-job questions
ClaudeFree / $20 mo
AI assistant known for careful writing, long-document analysis, and coding.
How a Low Code Developer uses it: analyze big reports or spreadsheets and turn messy notes into clean, finished writing
The approval shows the wrong person
The operations lead is sitting next to you, clicking through the app you built, and the approval step shows the wrong person. The form looked finished yesterday. Today a real request, with a real department and a real dollar amount, routed to someone who left the team. You are a low-code developer. You build business apps on a platform such as Power Platform, OutSystems, or a close cousin, and the data and the permissions are the product. The screen is only honest if the right human can see the record, change it, and approve it. Everyone else should meet a refusal the platform actually enforces.
Your morning is that table, that flow, and that role assignment. You open the request the lead just made, you see which rule chose the approver, and you fix the rule so the next request follows the org as it exists this month. You check the same path with a user who should be blocked. A demo that works under your own admin account is how these apps embarrass a department. You publish only after a person who does the job has clicked the path with their own login.
The people across the desk are process owners, business analysts, and the IT partners who guard the systems you connect to. They know the approval chain, the fields that must be stored, and the report they are tired of building by hand. You know the platform: what a flow can do, what a screen control can show, how a security role is granted, and how a change moves from a trial environment into the one the department uses. The decision you make together is whether this process fits the platform or whether someone is asking the tool to be a different kind of system.
The platform is the material
You spend the day inside the platform's designers: data tables, forms, workflows, connectors, and the security model. A new request type might mean a column, a validation, a screen, and a branch in the flow. You prefer the platform's own pieces when they express the rule clearly, because the next analyst has to live with your choice. You name things the business will recognize. A table called "Table7" and a flow called "Flow_final2" become the outage when you are out. The app should read like the process, not like a scratch pad.
Connectors are how the app meets systems the company already runs. You pull employee data, customer records, or inventory from the source that owns them, and you write back only what that source expects. You handle the failure when the other system is down: the user sees a clear stop, and you do not leave a half-saved request that looks approved. You keep credentials for those connectors in the platform's secret store, granted to the app, not pasted into a screen. Ship a flow only after it runs beyond your laptop connection.
Environments matter. You build where it is safe to break, you try the flow with non-production data or with carefully chosen samples, and you promote a known version into the environment people use. You keep a short note of what changed, because a flow edit can alter approvals with no obvious "release." If the platform has a maker area where enthusiastic colleagues experiment, you help them, and you still own the apps that touch real records. Helpful experiments and the system of record should not share a login and a shrug.
Before you publish to the department
Confirm the table, the connector, and the role with a real login: who can create, who can approve, who is refused, and what remains when the other system is unreachable. Your admin session hides all four.
Permissions are the feature
A business app fails in public when the wrong person sees a salary, a customer, or an approval button. You model roles with the process owner: requester, approver, auditor, admin. You test each role. You decide whether a manager sees one team or the whole company. You decide what an edit after approval is allowed to change. Row-level rules, if the platform offers them, belong in the design on day one. Bolting them on after a leak is how trust in the app ends.
You also plan for people moving jobs. The approval chain that names a specific colleague will rot. The chain that names a role, a team, or a field on the record will survive a resignation. When the org chart changes, you want a place to update that mapping without redrawing every flow. Sit with the operations lead and walk three cases: a normal approval, a refusal, and a person who changed teams last week. If the third case shows the wrong name, fix the chain before the department relies on the app.
Auditability is part of the same promise. Someone will ask who approved a request and when. The platform can usually record that, if you turned the history on and if you did not bypass it with a manual edit in the table. You show the process owner where that history lives. You refuse casual edits in production data as a way to "just fix" a record, unless the fix itself is recorded. The app is a business control. Treat it like one.
The limit of the platform is the job
The useful skill is knowing where the platform stops. A multi-step internal process, a form with validations, a connector to a system of record, a role model, a report the department refreshes: that is home territory. A pixel-perfect consumer product, a heavy calculation over huge volumes, a realtime experience, or a rule no visual flow can say clearly: that is where you pause. You tell the process owner what the platform will do well and what it will fake. Faking becomes a maintenance trap the next person cannot see until it breaks.
Sometimes the right move is a narrow extension: a custom connector, a small component, a script the platform allows at the edge. You take that on when it earns its keep, and you document it, because the extension is the part a future maker will fear. Sometimes the right move is to change the process so it fits the tool. Sometimes the right move is to say this belongs in a conventional codebase owned by another team. Saying so is part of your credibility. A low-code developer who never declines a request will eventually own a pile of exceptions that the platform fights every week.
You still learn enough of the platform's formula language, query tools, and extension points to be precise. You learn that formula language well enough to correct it, and you keep the process, the data, and the role at the center, expressed in the tool the company already pays to run. When you talk about your work, talk about the approval that now reaches the right person, not about a framework tour.
An app the department actually uses
No universal licence qualifies you to build on Power Platform, OutSystems, or their peers. Employers look for an app with real data and real permissions that people use. A vendor certificate from the platform maker can be a side signal that you have studied the tool. It does not replace the app. A hiring manager will ask who logs in, what they approve, and what you refused to build. Have those answers. A tutorial that creates a contact list under an admin account will not survive that conversation.
If you are early, build a sample that still has teeth: two roles, a flow that routes differently for each, a connector or a table with validation, and a case that must be refused. Write who the users are and what the platform cannot do in your design. If your paid apps are internal, prepare a walkthrough without confidential records. Describe the process, the roles, the environment you promoted through, and a mistake you fixed after go-live, such as an approver who had left. Offer to model a small process of theirs on a whiteboard so they can see how you listen.
Bring the mess as well as the screen. The time a connector failed, the role that was too wide, the request you pushed back into a normal software team. Judgment at the platform's wall is the proof that you do this job, rather than clicking controls until a demo appears. Departments remember the person who kept their data in the right hands.
Getting hired, then owning more of the process
Companies hire this role inside IT, inside a shared services group, or beside a department that has outgrown a pile of spreadsheets. You might come from business analysis and have learned the platform deeply, from IT support of the same platform, or from conventional software and have chosen this layer on purpose. Read the posting for the product name and for words like workflow, data, and security roles. A posting that wants a general product engineer and mentions a low-code tool once is a different week. Apply when the platform is the job.
The loop is a process conversation plus a look at something you built. They may ask you to sketch an approval app: data, roles, and what should block. Talk to the business rule before you talk to a control palette. Ask who the users are, which system owns the records, how a change gets promoted, and what happened the last time the wrong person could approve. Ask whether you will govern other makers or only build. Ask where the platform's wall already hurt them. Tell them your location needs and sponsorship needs on the first call.
The first job is often one department's app, with a senior reviewing your roles. You learn the tenant, the environments, and the politics of a process owner who wants an exception. Evidence you are ready for more is an app still in use after the org changed, with roles that stayed tight. Later you may own a family of apps, set the patterns other makers must follow, or lead the group that runs the platform. Some people move back toward conventional engineering for problems that did not fit. Choose using the processes you want to live with. Describe the next role by the records and the approvals, not by a badge.
Pay for an app the business runs on
When the letter is for platform-built business apps, the May 2025 Occupational Employment and Wage Statistics series for Software Developers from the Bureau of Labor Statistics is the published band this title gives you. The starting figure is $82,460 and the median is $135,980, with $53,520 between those two. Internal tools sometimes get talked down because the interface was assembled on a platform. The published band does not care about that story. If you already ship apps with real roles, real connectors, and a promotion path between environments, and they price you at the start, name the $53,520 and attach it to the process you put in people's hands. A first app under close review can sit nearer the start. Say which one the letter describes.
The medians in Massachusetts, New York, and Washington are $165,210, $166,180, and $166,540. A company choosing among those states will not find a wide gap in typical pay; the process you would own and the city will matter more. Oregon's median is $142,720. California's state median is $174,410, which is $38,430 above the national median. The top-of-range California wage shown here is $272,670, in a state the chart reports, and the distance from the national median to that high end is $136,690. Use $174,410 when the offer is a solid platform seat in California. Use $272,670 only if you would set patterns for many departments, govern other makers, and carry the hard calls at the platform's wall. A single form under supervision is a different scope.
Puerto Rico's median is $79,380, the lowest typical pay listed. It sits near the national entry figure and should be used as typical pay for that place, not as a way to describe a California role. If a recruiter borrows the California high end for a department app in Oregon, return to $142,720 and to $135,980. Then talk about the permissions model. That model is the work they are buying, whether or not the screens came from a visual designer.
Put the offer next to the entry figure, the median, and the state median when the state appears on the chart. If the title sounds senior and the number hugs $82,460, ask whether you govern roles for other makers or follow a script. If the number already matches a New York or Massachusetts median, write down the review cycle and any bonus before you celebrate. Stop when the offer names the business process, the permission model, and the published figure you are willing to accept.
The top of Low Code Developer pay — and how to get there with AI
$272,670what Low Code Developer pay reaches in California
Highest state-level top-of-range annual wage for Software Developers, among states with at least 500 people in the job. U.S. Bureau of Labor Statistics, Occupational Employment and Wage Statistics, May 2025.
And the role it leads to — Computer Hardware Engineers — reaches $281,210 in California.
$82,460entry$135,980middle$272,670top end
Almost anyone can assemble a working screen in a week; the low code developer paid at the top of this range is the one who can show, from monitoring data and a written specification, that the thing still behaves six months later.
The real task list for this role leans harder on stewardship than on dragging components onto a canvas: monitoring whether a system runs in conformance with its specifications, storing and retrieving data to work out what that system can actually handle, preparing reports on project status, and training users on whatever just changed. Fast builders skip every one of those and then spend the year firefighting. The people at the top of the range instrument first. A model can draft test cases, condense an error log, or turn a change list into release notes, but somebody still has to decide what counts as broken, and that decision is the part that gets priced.
Your playbook, by where you are now
Just startingInstrument before you decorate
Write down, before you build anything, what the app must do and what would count as a failure, then keep that sheet beside the finished screens.
Log every run of your automations somewhere queryable, an Airtable base or an Amazon DynamoDB table, rather than trusting the platform's own history view.
Sit with two real users while they work through what you built and record every point where they hesitate.
Ask Claude to generate awkward edge-case inputs for a form you just finished, then run them yourself and repair what breaks.
What proves it: One app with a written specification, a failure list, and a count of how often each failure occurred.
Realistic span: your first year
A few years inOwn the release, not just the build
Take over the report on project specifications, activities and status that somebody currently writes badly or not at all.
Set thresholds and publish them: how slow is too slow, and how many failed runs in a week force a rebuild.
Pull your usage and error data into Alteryx software or a sheet you refresh weekly, and show the trend at the team meeting.
Run the user training yourself whenever an app changes, and note which changes produce support tickets.
Have Microsoft Copilot turn your change log into release notes, then check every line against what actually shipped.
What proves it: A quality report on your platform's apps that the team reads before deciding what to build next.
Realistic span: years two through five
ExperiencedSet what the platform is allowed to do
Write the standards other builders follow: naming, data retention, and who may connect which system to what.
Evaluate and recommend the platform purchase itself, weighing cost, security needs and the reporting formats the business requires.
Supervise and assign work to the programmers and technicians building on your platform, and review what they ship against those standards.
Move toward hardware and systems engineering if the infrastructure side interests you, since specifying capacity and configuration is the same habit at a larger scale.
What proves it: A published platform standard plus a governance review you personally run.
Realistic span: five years and up
The next 90 days
Pick the app on your platform that people complain about most and spend a fortnight measuring it instead of rebuilding it. Count the runs, count the failures, and time how long each screen takes under real data volumes. Put that data somewhere you can query later. Then write a single page: what the app was meant to do, what it does now, and the three specific things that would have to change. Hand it to whoever holds the budget. California pays this work best, and what those employers screen for is somebody who can defend a system, not just demonstrate one.
Wage figures: BLS OEWS, May 2025. The playbook is PayCrunch editorial guidance, not a guarantee of pay or placement.
Every figure is the national median from the U.S. Bureau of Labor Statistics (OEWS) shown on that role’s own page.
Never used AI before? Start here (2 minutes).
Start with the AI copilot inside your primary platform. If you're on Microsoft, open Power Apps and Power Automate with Copilot and describe an app or flow in plain English to see it scaffolded instantly; on Retool, use Retool AI; on OutSystems or Mendix, use their AI assistants. This is where AI most changes your daily output — first drafts of apps and flows in minutes instead of hours.
Then learn the 2026 premium skill: building AI agents in Microsoft Copilot Studio (or with Power Platform AI Builder). Use Claude or ChatGPT as your pair-programmer for the hard 20% — Power Fx, JavaScript, custom connectors, and SQL. Free learning: Microsoft Learn's Power Platform paths, OutSystems/Mendix academies, and the vendor docs. Never wire AI or connectors to real data without governance — you own what ships.
The one rule, forever: Low-code plus AI makes it trivial to ship apps that leak data or take unsafe actions. Never wire a connector or AI agent to production data without least-privilege access, DLP policies, and testing in a non-prod environment; never let an AI agent execute irreversible actions (payments, deletes, customer emails) without a human approval step. Keep secrets out of app formulas and out of public AI prompts. You own what your app does.
The plays — exact steps, exact prompts
Do these in order. Each one is copy-paste ready. You do not need to know anything about AI going in.
1
Build AI agents and copilots — the 2026 premium skill
Why this pays: AI agents that answer questions and take actions are the most valuable thing a low-code developer can build right now, and few can do it well. Owning agent development in Copilot Studio puts you in the scarce, top-of-band tier while others still build forms.
Microsoft Copilot StudioPower Platform AI BuilderPower Automate
1
Use Microsoft Copilot Studio to build a custom copilot: define its topics, ground it on your organization's knowledge (SharePoint, docs) with retrieval, and connect actions via Power Automate flows — so it can both answer and do.
2
Prompt AI to spec the agent before you build it.
Copy-paste this prompt
You are a conversational-AI solution architect. Help me design an AI agent for [use case, e.g. IT helpdesk triage]. Define: the agent's scope and out-of-scope boundaries, the top 10 user intents/topics, the knowledge sources it should retrieve from, the actions it should take (with which needing human approval), the guardrails and fallback-to-human rules, and how to measure success. Then outline how to build each part in Copilot Studio.
Every action that changes data or contacts a customer needs a human-approval or confirmation step — never let an agent act irreversibly on its own. Test on non-prod data first.
3
Pilot the agent with a small user group, measure deflection/resolution, and expand scope from there — a working agent with real usage numbers is your promotion case.
What you'll haveA deployed, governed AI agent with measurable adoption — the scarce 2026 skill that lands you in the top of the pay band.
2
Generate apps and automations from natural language
Why this pays: The core of the job — delivering apps and workflows — is now 5-10x faster with AI generation. The developer who ships more solutions per quarter clears the backlog and takes on bigger projects, the throughput that earns seniority and pay.
Power Apps (Copilot)Retooln8n
1
Describe the app you need to Power Apps Copilot or Retool AI — tables, screens, and logic — to generate a working first draft, then refine the data model and UX by hand.
2
Prompt AI to design the data model and app structure before building.
Copy-paste this prompt
Act as a low-code solution designer. I need an app for [business process, e.g. equipment checkout]. Design: the data tables and relationships (with key fields and types), the core screens and their purpose, the user roles and permissions, the key automations/flows (triggers and actions), and the top 3 edge cases to handle. Output so I can build it in [Power Apps / Retool]. Note where an AI feature (classification, extraction, chat) would add value.
Validate the data model and permissions before building — AI over-simplifies relationships and rarely gets access control right. Test with non-prod data.
3
Use AI to write the automation logic (Power Automate, n8n, Make), then test each branch — shipping reliable flows fast is what grows your project load.
What you'll haveMore apps and automations delivered per quarter — the throughput that clears the backlog and earns bigger, higher-paid projects.
3
Embed LLMs into your business apps
Why this pays: Apps that read documents, classify tickets, or chat are worth far more than static forms. The developer who bakes AI into everyday business apps delivers outcomes leadership can see — the differentiated work that commands top pay.
Power Platform AI BuilderAzure OpenAIOpenAI connector
1
Use AI Builder prompts or the Azure OpenAI / OpenAI connector inside your flows to add document summarization, data extraction, sentiment/classification, and drafting to existing apps.
2
Prompt AI to design an intelligent document-processing flow.
Copy-paste this prompt
Design a low-code flow that processes incoming [invoices/applications/emails]: trigger on arrival, use AI to extract [fields], validate against business rules, route exceptions to a human, and write clean records to [Dataverse/database]. Specify each step, the AI prompt for the extraction, the confidence threshold for auto-vs-human handling, and error handling. Platform: [Power Automate / n8n].
Set a confidence threshold below which items go to a human, and log every AI decision for audit — never fully automate a decision with legal or financial consequence.
3
Measure the manual hours the intelligent flow removes — a documented FTE-equivalent saved is the number that justifies your value and a raise.
What you'll haveBusiness apps that read, classify, and draft — the AI-infused solutions whose measurable savings command top-of-band pay.
4
Use AI as your pair-programmer for the hard 20%
Why this pays: The gap between a citizen developer and a paid professional is the complex 20% — custom formulas, JavaScript, connectors, and SQL. AI helps you clear that gap fast, so you handle the hard requirements others punt, which is exactly what employers pay the top rate for.
ClaudeGitHub CopilotChatGPT
1
Use Claude or GitHub Copilot to write and debug Power Fx, JavaScript for custom components, complex SQL, regex, and custom-connector OpenAPI definitions — the pieces low-code tools can't generate for you.
2
Prompt AI to solve and explain a specific hard problem.
Copy-paste this prompt
You are an expert in [Power Fx / Retool JS]. I need to [describe the exact requirement, e.g. a delegable filter across two tables with a date-range and a search box]. Write the formula/code, explain why it works and how it respects delegation/performance limits, and show how to test it. Here's my current attempt and the error: [paste code + error].
Understand the code before you ship it — AI can produce non-delegable or non-performant patterns that break at scale. Test with realistic data volumes.
3
Keep a personal snippet library of AI-solved patterns (delegation-safe filters, custom connectors) you can reuse — that accumulated capability is what makes you the go-to developer.
What you'll haveThe hard requirements others avoid, handled fast — the professional-grade capability that separates a paid developer from a citizen one.
5
Own governance and the Center of Excellence
Why this pays: As AI lets everyone build apps, sprawl and data-leak risk explode — and organizations pay well for the person who governs it. Running the Center of Excellence makes you the platform owner, not a builder among many: the leadership route to $272,670+.
Power Platform CoE Starter KitMicrosoft PurviewClaude
1
Deploy the Power Platform CoE Starter Kit to inventory every app, flow, and connector, set environment strategy and DLP policies, and monitor for risky connector combinations and orphaned apps.
2
Use AI to author the governance standards and a citizen-developer program.
Copy-paste this prompt
Act as a Power Platform / low-code governance lead. Draft a Center of Excellence framework for an organization scaling low-code and AI agents. Cover: environment strategy (dev/test/prod), DLP policy principles, an app/agent approval and review process, security and least-privilege standards for connectors, an application-lifecycle-management approach, and a citizen-developer enablement and guardrails program. Output as a practical policy document with a rollout plan.
Adapt to your organization's real security and compliance requirements and get security/IT sign-off — governance is only real if it's enforced, not just written.
3
Run the review board that approves apps and agents into production — being the gatekeeper and enabler for the whole platform is the role that pays at the top.
What you'll haveA governed platform you own end to end — the Center-of-Excellence leadership role that reaches the top of the band.
Your 12-month sequence to the top of the range
How the plays above stack into a path from median pay toward the $272,670 tier.
Month 1
Turn on Copilot in your primary platform and use natural-language generation for every new app and flow; refine the data model and permissions by hand.
Months 2-3
Use AI as your pair-programmer to master the hard 20% (Power Fx, JS, custom connectors, SQL) so you can take on complex requirements.
Months 3-6
Embed LLMs into real apps (document processing, classification, chat) and document the manual hours each one removes.
Months 6-12
Build and pilot a custom AI agent in Copilot Studio with real users and adoption metrics.
Year 2
Stand up governance and the Center of Excellence — the platform-owner role that reaches the $272,670 top of the band.
Gear for this job
As an Amazon Associate, PayCrunch earns from qualifying purchases. Links to books and tools are for the job on this page; we only recommend what we’d use in the work.
Same live O’Reilly 7th already on web-developer. This page’s hard-20% play is literally Power Fx, JavaScript, custom connectors, and SQL. Not McKinney pandas (that is data-scientist / market-research-analyst) and not CompTIA Security+ (that is software-engineer / infosec).
Next steps for a Low Code Developer
Some links below are affiliate or partner links. PayCrunch may earn a commission if you enroll or subscribe through them, at no extra cost to you. Wage figures on this page still come from the Bureau of Labor Statistics, not from these programs.
Low Code Developer work is specific enough that a stamped 'check out these courses' block would be noise. BLS files this work as Software Developers (SOC 15-1252). O*NET Job Zone 4 is typical: a bachelor's degree, so the honest next credential is a professional certificate or bachelor's-level coursework — not a random catalog dump.
Low Code Developers in this dataset list AJAX among the tools in use, so a program that names that stack is a better fit than a survey course.
The next title this dataset points at is Computer Hardware Engineers; a credential aimed that way is a clearer step than another year in the same seat.
Coursera search for computer science — a professional certificate or bachelor's-level coursework that lines up with computing, not a generic professional-development aisle.
FlexJobs screens remote, hybrid, freelance, and flexible listings so you are not wading through unverified ads. This is a job-board search for Low Code Developer work, not a claim that they list a counted SOC 15-1252 inventory.
Write a Low Code Developer resume, or one aimed at Computer Hardware Engineers, instead of a blank template. Resume Now is a resume builder; we are not claiming a counted template set for this SOC.
A Low Code Developer resume that names the actual tasks on this page, or the step-up title Computer Hardware Engineers, beats a blank template when you apply.
What Low Code Developers earn by state
These are the Bureau of Labor Statistics’ own figures for Software Developers, state by state — not a cost-of-living adjustment applied to the national number. Only states employing at least 500 people in the occupation are shown, because a state median drawn from a handful of workers is noise rather than a signal.
California
$174,410
highest of them · +28% vs the national median
Puerto Rico
$79,380
lowest of the 51 states and territories that qualify · -42% vs the national median
The same job pays $95,030 more a year at the median in California than in Puerto Rico — 120% higher. That gap is what the Bureau measured, before any question of what it costs to live in either place. California also carries the top of this job’s range, $272,670 — the figure quoted at the head of this page.
Source: U.S. Bureau of Labor Statistics, Occupational Employment and Wage Statistics, May 2025, SOC 15-1252. 51 states and territories clear the 500-employee reporting floor for this occupation; those below it are left out rather than shown with a wide error band.
Free data. Use any of it.
PayCrunch publishes verified, BLS-sourced salary + AI-playbook data on 1,000+ professions — free, no signup.
It replaces the shallow end of the work, not the role. When anyone can generate a simple app from a prompt, developers who only drag and drop lose their edge. But someone still has to design the data model, get access control right, integrate systems, handle the complex 20%, build AI agents safely, and govern the whole platform — and AI makes that person more productive, not redundant. The path is clear: move up from builder to architect and governance owner.
Can I trust an app or agent that AI generated?
Only after you review and test it. AI over-simplifies data relationships, frequently gets permissions and access control wrong, and can produce non-delegable or non-performant patterns that break at scale. Always validate the data model, test in a non-prod environment, and never let an AI agent take irreversible actions without a human approval step. The build is fast; the responsibility is still yours.
Is it safe to use ChatGPT for low-code work?
For code and design help, yes; for data and secrets, no. Use Claude or ChatGPT to write Power Fx, JavaScript, SQL, and connector definitions and to design app structure — that's safe and hugely productive. Never paste API keys, connection strings, or real customer/business data into a public tool, and keep secrets out of app formulas. For anything touching production data, use governed enterprise AI and least-privilege connectors.
How does AI actually increase a low-code developer's pay?
By moving you up the value ladder. AI generation multiplies how many apps and flows you ship; AI pair-programming lets you handle the complex requirements that command professional rates; embedding LLMs into apps delivers measurable FTE savings; building AI agents puts you in a scarce, high-demand skill; and owning governance makes you the platform leader. Each rung — from builder to architect to CoE owner — is a step toward the $272,670 top.
Which AI skill should I build first?
Copilot in your primary platform, because it changes your daily output immediately. Once that's routine, invest in building AI agents in Copilot Studio — it's the scarcest, highest-value low-code skill of 2026 and the clearest differentiator for top-of-band pay.
Methodology & sources
Salary (median, 10th, top of the range) — U.S. Bureau of Labor Statistics, OEWS.
By state — the Bureau of Labor Statistics’ own state medians, limited to states employing at least 500 people in the occupation. No cost-of-living arithmetic is applied to a wage anywhere on this page.
The plays — PayCrunch's own step-by-step guidance using publicly available AI tools. Tool names/URLs are real and current as of August 2026; prompts written to work as-is. Verify any professional output before relying on it.