AI at Inetz

The world is changing. We're building at the speed of it.

We build custom web applications and the secure infrastructure they run on. AI is changing how that work gets done. We use it to the fullest, to build more, build faster and keep everything we build secure.

Tell us the problem > See how we build

What we know

We can't say what the next year looks like.
We can say it will move fast.

Nobody knows exactly what technology will look like in 12 months, 24 months or ten years. What we do know is that AI is moving technology forward at a pace we have never seen in nearly 30 years of business. We use it to the maximum extent we responsibly can, so the systems we build are capable and secure, and so we can advance their features faster than was ever possible before.

How we build

AI at every step. People at every decision.

Every project we build goes through the same seven-stage cycle. AI does the heavy lifting at each stage, finding the gaps, writing the code, reviewing it, attacking it and documenting it. Our engineers make the decisions, and nothing moves on until they say so.

  1. 01

    Frame

    We start by writing the problem down.

    AI does

    Turns conversations, documents and the old system into a written problem statement. Says it back to us, lists the assumptions it is making and asks the questions we have not asked yet.

    We decide

    What is in scope, what success looks like and what is not worth building.

  2. 02

    Probe

    We look for gaps before any code exists.

    AI does

    Reads the plan like a skeptic: missing requirements, rules that contradict each other, unclear data, edge cases, and anywhere the design touches regulated data or widens the compliance scope.

    We decide

    Judge which gaps matter, settle the architecture and write the decisions down, so every later step starts from the same plan.

  3. 03

    Build

    Small pieces, each one readable.

    AI does

    Writes and refactors code in small increments, against the written plan and the project's conventions, with tests alongside.

    We decide

    Steer the work, own the design and keep every increment small enough for a person to read.

  4. 04

    Review

    Every change is read twice before a person reads it.

    AI does

    One pass checks the change against the plan and the conventions. A second, independent pass looks for bugs, missed cases and anything that does not belong.

    We decide

    An engineer reads the change with the findings in hand and decides whether it is ready.

  5. 05

    Harden

    We attack our own work first.

    AI does

    Reviews input handling, access control, secrets, dependencies, headers and server configuration. Reasons through how an attacker would approach the system, and watches the logs of running systems for probing.

    We decide

    Which findings are fixed now, and which risks are accepted and written down.

  6. 06

    Prove

    Show that it works, and keep the paperwork current.

    AI does

    Writes and runs tests, checks accessibility and speed, and updates the documentation and change notes in the same change as the code, so compliance evidence is a by-product, not a project.

    We decide

    Verify the results, approve the release and sign the change.

  7. 07

    Run and learn

    Shipping is a step, not the end.

    AI does

    Helps read logs and alerts, spots drift between what was approved and what is deployed, and turns every defect or near miss into a new check or note for the next cycle.

    We decide

    Deploy, operate and respond, and set what the next cycle should change.

What we learn goes into the next cycle.

The gates

Every change earns its way in

Nothing we build reaches production on one person's say-so, or one AI's. A change passes seven gates in order. Fail any of them and it goes back a step, not forward.

  1. 1

    Draft

    AI writes the change against the plan

  2. 2

    Self-check

    It re-reads its own work against the plan and the conventions

  3. 3

    Second opinion

    An independent pass, with different instructions, hunts for bugs and gaps

  4. 4

    Security pass

    Input, access, secrets, dependencies and configuration

  5. 5

    Automated checks

    Tests, style and static analysis run, and must pass

  6. 6

    Engineer review

    A person reads the change and the findings

  7. 7

    Approval

    A person approves it and releases it

  • AI
  • Automated check
  • A person

How deep it goes

Seven concerns. Looked at again and again.

Security is not a step at the end, and neither is anything else. Each concern is checked at several stages, with one stage where it gets the closest look.

1 Frame 2 Probe 3 Build 4 Review 5 Harden 6 Prove 7 Run and learn
Requirements fit
Architecture and design
Code quality
Security
Compliance (PCI DSS, NIST)
Speed and reliability
Documentation
  • Main focus
  • Also checked

Ground rules

What does not change, however fast it goes

  • People decide

    An engineer reviews every change. AI does not commit, merge or deploy. People do.

  • Sensitive data stays out

    Credentials, client data and cardholder data never go into AI tools. The work runs on code and test data.

  • Written down

    Plans, decisions and documentation live in the project and change with the code, so anyone can see what was built and why.

  • Verified, not assumed

    What AI suggests is checked before it touches a production system. Every claim is backed by a test, a log or a person.

Because every change is planned, reviewed, tested and recorded, the cycle leaves behind the evidence that PCI DSS and NIST reviews ask for. AI supports our compliance work. It does not replace the controls, the audits or the people accountable for them.

What you get

AI
At Work

01 Engineers direct. AI builds. 02 Weeks become days 03 Custom is back 04 Security at every stage 05 Compliance as a by-product 06 Modernize what you already have

01

Engineers direct. AI builds.

Our engineers set the direction and own every decision. AI agents do the building: drafting code in small increments, checking it against the plan, writing the tests and keeping the documentation current. Developers call this agentic development. Nothing moves to the next stage until an engineer says so.

  • Engineers own the architecture, the trade-offs and what ships
  • AI agents write, refactor and test the code, in pieces small enough to read
  • Every change passes seven gates before it is released
  • Plans, decisions and documentation live in the project and change with the code

For you Senior engineers stay accountable for what you get, and the work moves at AI speed. See the Build stage

02

Weeks become days

What used to take weeks or months can now take days or hours.

Prototypes, integrations, data migrations, reports and whole features move from idea to working software far faster than they did only a few years ago. You see something real sooner, you can steer it sooner, and you start getting value sooner.

Faster does not mean careless. The time AI gives back goes into design, testing and security, which is where it pays off.

Speed is safe because of the gates. Every change is checked by AI twice, tested, and read by an engineer before it is released.

For you A working version to react to in days, not a specification to wait on. See the gates

03

Custom is back

Custom software used to be the slow choice. Not anymore.

Custom development has long had a reputation for taking longer and costing more than buying a packaged product. Building with AI changes that. We can build a system around your problem faster than you could implement and configure an off-the-shelf package, and the result is a better fit.

  • Faster: often a working system in days or weeks, not a long implementation project
  • More accurate: it does what your process actually requires, with no workarounds
  • More capable: features arrive on your schedule, not a vendor's roadmap
  • More optimized: no unused modules, built for your data and your traffic
  • More secure: less code means less to attack, and no popular package for attackers to scan the internet for

This applies to the systems most businesses run on, from e-commerce to content management to ERP. With AI behind it, custom web application development is now the preferred direction for many businesses.

For you A system shaped around how you work, not the other way around. See how we build web applications

04

Security at every stage

Attackers are using AI to find weaknesses and move faster. Defenders have to do the same, and not only at the end. Security gets a look at every stage of our cycle, with its closest look at Harden, before anything is released.

  • Reviewing code and configurations for vulnerabilities as they are written
  • Reasoning through how an attacker would approach the system, and fixing it first
  • Checking inputs, access control, secrets, dependencies and server settings on every build
  • Watching logs and alerts on running systems, so probing and problems surface sooner

We also use AI carefully. Credentials, client data and other sensitive information stay out of AI tools, and what AI suggests is verified before it touches a production system. This work complements formal penetration testing where a standard requires it. It does not replace it.

For you Weaknesses found by us before someone else finds them, and a system that is still watched after launch. See the Harden stage

05

Compliance as a by-product

Meeting PCI DSS and staying aligned with NIST are continuous work, not an annual event. Because every change is planned, reviewed, tested and recorded, our cycle leaves the evidence behind as it goes: the change record, the test results, the review findings and up-to-date documentation.

AI also helps us spot drift between what is required and what is deployed, and flags a design that would widen your PCI scope before it is built.

AI supports our compliance work. It does not replace the controls, the audits or the people accountable for them.

For you Less scrambling when an assessor asks how a change was made and who approved it. See the coverage map

06

Modernize what you already have

Most businesses run software they depend on and are afraid to touch: an aging application, an unsupported language version, a system nobody has documentation for. AI makes it practical to modernize these without starting from nothing.

  • Reading the old code and working out what it really does
  • Writing the documentation and tests that never existed
  • Carrying out migrations and upgrades in small, checked steps
  • Moving over in stages, so the business keeps running

We used the same method to move our own site from a legacy platform to a modern framework, with the plan, the tests and the documentation produced along the way.

For you A way forward for the system you depend on, and a clear picture of what it does today. See the Probe stage

Let's Talk
About AI

Start a conversation

Tell us the problem >

See what we build

Services >