The Australian Institute of ICT (AIICT) has introduced a new ‘Certified Artificial Intelligence Professional’course, jointly developed with Amazon Web Services (AWS)for aspiring Artificial Intelligence (AI) developers and Machine Learning (ML) professionals.

The course enables novice practitioners who are interested in entering the field of AI to become job-ready engineers in just six months. There will be a skill assessment to evaluate the student’s current skills and experience, but the only prerequisites are a basic understanding of mathematics and statistics and, or alternatively, relevant experience in the industry, such as an internship.

According to the 2020 IT Skills and Salary Report, ‘AI, cognitive computing and machine learning’ was reported as the second weakest IT skillset in organisations across the world, presenting serious hiring challenges for IT managers.[1] The lack of skilled AI professionals forms part of a broader technology skills shortage in Australia, with new research commissioned by AWS revealing that Australia will require an additional 6.5 million newly-skilled and reskilled digital workers by 2026 to meet future demand for technology skills (79 per cent more than Australia currently has).

Jon Lang, CEO of AIICT said, “We’re seeing a severe shortage of skilled AI professionals and in many instances, organisations are simply unable to fill these roles. With AI and ML becoming a critical part of the digital transformation process for many organisations, the demand is on the rise for engineers with these specific skills across a wide range of industries.”

“At AIICT, we are committed to providing all our students with the most contemporary, relevant and future-focused skills. Together with AWS we hope to address the skyrocketing demand in the AI field and support those looking to start their career as an AI engineer,” added Lang.

An ‘Artificial Intelligence Specialist’ is currently the top emerging job role in both Australia and the United States, according to the LinkedIn 2020 Report, with hiring growth surging 74% annually in the last four years.[2]

Moreover, as of January 2021, the average salary for a Machine Learning Engineer in Australia is estimated at $94,255 ($1,812 weekly), according to Indeed.[3] This is 34% above the average annual earnings for all employees in Australia, which is $66,575 ($1,280 weekly), according to the ABS[4].

“There have been rapid technological advances in cloud computing, machine learning and artificial intelligence, however we still face an ongoing skills shortage in these areas,” said Melanie Botha, Head of Training and Certification, Australia and New Zealand. “AWS is passionate about continual education, and the need to build new digital skills to drive economic growth and job creation in Australia and New Zealand. Together with AIICT, we want to close the digital skills gap, equip individuals with job-ready skills that will boost their employability, and support the upskilling of our nation.”

AIICT is a start-up launched in 2019 by DDLS, one of Australia’s largest providers of corporate IT and cybersecurity training, and is one of only two authorised AWS Training Partners in the country.

The Certified Artificial Intelligence Professional course prepares individuals for a role as an entry-level AI developer or Machine Learning Engineer. Through its unique Industry Partner Program, AIICT connects recent graduates with leading employers to help them secure a front-line role, while simultaneously tackling skills shortages in the field.

The course incorporates three globally recognised AWS certifications, including AWS Certified Cloud Practitioner, AWS Certified Data Analytics and AWS Certified Machine Learning, as well as the TensorFlow Developer Certificate.

The hands-on course places a high focus on the development of real-world skills, and provides students access to unique ‘live labs’, which enable them to practice developing and deploying machine learning models in a simulated work environment.

The course platform also includes video content, quizzes, expert led webinars and direct access to online mentorship from industry experts, who are on hand to guide students through the course material.

AIICT operates using a unique self-paced course schedule, which is not bound by the traditional academic structures of terms and semesters. The flexible learning options allow students to build an online learning schedule around their life and encourages people who may not have considered a career in AI as an option previously, to undertake training.

The AIICT platform also allows students to join a community of like-minded individuals for communication and collaboration as they progress through the course.

Some of the course’s key learning outcomes include:

Understanding the fundamentals of AI/ML processes and concepts, and elements of data science.
Learning the key concepts of cloud computing with a deep dive into AWS.
Gaining skills in Python, SQL JavaScript, and Deep Learning.
Learning how to build scalable AI-powered algorithms with TensorFlow.
Exploring ML toolsets and processes to build models with Amazon SageMaker and computer visions based on smart applications.
Understanding data analytics and its application to AWS

AIICT

The Australian Institute of ICT (AIICT) is a start-up launched by DDLS, Australia’s largest provider of vendor-certified cybersecurity and ICT training in Australia. Launched in 2019, AIICT was designed to provide those in the ICT and cybersecurity industries, or those looking to enter the industries with the most contemporary, relevant, and future-focused skills needed to succeed. As an operational division of DDLS, AIICT aims to provide online, self-paced, and nationally accredited cybersecurity and ICT training, leveraging the experience, skills and knowledge DDLS has accumulated as leaders in this industry for more than 30 years. The training is delivered via the Moodle LMS platform and leverages world renowned content from CompTIA, Skillsoft, Microsoft and LinkedIn Learning.

This article is written as an accessible, plain-language introduction to both technologies. It is not an exhaustive reference — think of it as the foundation you need before diving into the official documentation or a hands-on tutorial.

What Is Docker?

Docker is software that packages applications into portable, self-contained units called images. To appreciate why that matters, consider what it takes to share an application you have written.

Suppose you write a To-do app in Node.js. On your machine you have the right runtime installed, the right libraries, and the right environment variables set. You hand the source code to a friend who runs a different operating system. Immediately, problems appear: missing dependencies, wrong library versions, a different file-system layout. The code that works perfectly on your laptop does not run on theirs.

Docker solves this by bundling your application together with everything it needs to run — the OS filesystem, runtime, libraries, and configuration — into a single artefact called a Docker image. That image can be executed on any machine that has a Docker runtime installed, regardless of the underlying operating system.

Images vs. Containers

• Image: A read-only blueprint that describes what your application and its environment look like.
• Container: A running instance of an image — an isolated process on the host machine.

A common concern is that shipping an entire OS filesystem sounds heavy. In practice, minimal Linux distributions such as Alpine Linux are only a few megabytes, so images can remain very lean.

The workflow is straightforward:

1. Write a Dockerfile that describes how to build your image.
2. Run docker build to produce the image.
3. Push the image to a registry (such as Docker Hub or a private registry).
4. Anyone with Docker installed can pull and run the image with a single command.

So Where Does Kubernetes Come In?

Docker is excellent at packaging and running a single container. But real-world production services are rarely a single container running on a single machine. They involve many containers, many machines, traffic spikes, failures, rolling updates, and dozens of other operational concerns. Managing all of that by hand does not scale.

Returning to the To-do app example: you have packaged it as a Docker image and you want to expose it as a public web service. Now you face a new set of questions:

• What happens when the container crashes? Does it restart automatically?
• How do you handle a sudden surge in traffic without manually provisioning more servers?
• How do you roll out a new version without downtime?
• How do you route traffic to healthy instances only?
• How do you restrict which parts of your system can talk to each other?

Kubernetes answers all of these questions. It orchestrates your containers — deciding where they run, restarting them when they fail, scaling them up or down based on load, and exposing them to the network in a controlled way.

Core Kubernetes Concepts

You do not need to memorise every Kubernetes primitive before getting started, but the following four concepts form the foundation of almost everything else.

1. Clusters and Nodes

Kubernetes operates on a cluster — a group of machines (physical or virtual) that work together. Each machine in the cluster is called a node.

Nodes come in two roles:

• Control-plane nodes (formerly called master nodes): Run the Kubernetes system components that make cluster-wide decisions — what to run, where to run it, and whether the current state matches the desired state.
• Worker nodes: Run your application workloads. They receive instructions from the control plane and report back their status.

2. The Control Plane

The control plane is the brain of the cluster. Its core components include:

• kube-apiserver: The front door to the cluster. Every interaction — from the CLI, from internal components, from external tooling — goes through the API server.
• kube-scheduler: Watches for new workloads and decides which node they should run on, based on available resources and constraints.
• kube-controller-manager: Runs control loops that continuously reconcile the current state of the cluster with the desired state you have declared.

Worker nodes run two key agents:

• kubelet: Ensures containers described in Pod specs are running and healthy on that node.
• kube-proxy: Manages network rules on the node to enable service-to-service communication within the cluster.

3. Declarative Configuration

You interact with Kubernetes by describing what you want, not how to achieve it. You write a configuration file — in YAML or JSON — that declares the desired state, and Kubernetes works continuously to make reality match that declaration.

A minimal example of a Kubernetes Deployment manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: todo-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: todo
  template:
    metadata:
      labels:
        app: todo
    spec:
      containers:
        - name: todo
          image: your-registry/todo-app:latest
          ports:
            - containerPort: 3000

This tells Kubernetes: run three copies of this container image and keep them running. If one crashes, Kubernetes automatically starts a replacement.

4. kubectl — The CLI Tool

The primary way to interact with a Kubernetes cluster is through kubectl, the official command-line interface. Common operations include:

• kubectl apply -f deployment.yaml — apply a configuration file to the cluster.
• kubectl get pods — list running pods.
• kubectl logs <pod-name> — stream logs from a container.
• kubectl describe pod <pod-name> — inspect a pod’s events and status.

What Kubernetes Handles for You

To make the value concrete, here is a summary of what Kubernetes manages once your application is deployed:

• Self-healing: Failed containers are restarted automatically. Nodes that become unresponsive cause their workloads to be rescheduled elsewhere.
• Horizontal scaling: Increase or decrease the number of running replicas with a single command or automatically via a Horizontal Pod Autoscaler.
• Rolling updates and rollbacks: Deploy a new version gradually, with automatic rollback if health checks fail.
• Service discovery and load balancing: Kubernetes assigns DNS names to services and distributes traffic across healthy pods.
• Secret and configuration management: Sensitive data (API keys, passwords) and configuration values can be injected into containers without baking them into the image.
• Storage orchestration: Automatically mount storage systems — local disks, cloud volumes, network file systems — to containers that need them.

Getting Started: Practical Advice

Before standing up a full production cluster, use local tooling to learn the concepts without cloud costs:

• minikube — runs a single-node Kubernetes cluster inside a VM or container on your laptop. Ideal for development and experimentation.
• kind (Kubernetes IN Docker) — runs Kubernetes clusters using Docker containers as nodes. Fast to start and popular for CI pipelines.
• k3s — a lightweight, production-grade Kubernetes distribution suited to edge, IoT, and resource-constrained environments.

For production deployments on AWS, tools such as kops (Kubernetes Operations) and managed services such as Amazon EKS, Google GKE, or Azure AKS significantly reduce the operational overhead of managing the control plane yourself.

Further Reading

The official Kubernetes documentation is thorough and well-maintained. The interactive tutorial at kubernetes.io/docs/tutorials/kubernetes-basics walks you through deploying, scaling, and updating an application against a live cluster — all from the browser, no local setup required.

Once you are comfortable with the basics, explore the concepts reference at kubernetes.io/docs/concepts to understand the full object model and how the scheduler, controller manager, and kubelet interact.

Kubernetes has a steep-looking learning curve from the outside, but once the mental model clicks — declare what you want, let Kubernetes figure out how — the pieces fall into place quickly.

Where Is Ansible Used?

Before exploring the career benefits, it helps to understand where Ansible fits in a modern infrastructure. Ansible is primarily used to automate three categories of work:

• Configuration management: Changing OS settings, managing services, and installing or updating software across many hosts simultaneously.
• Provisioning: Spinning up and configuring the servers, virtual machines, or cloud instances that make up your infrastructure.
• Application deployment: Pushing application code to production environments in a consistent, repeatable way.

Ansible certification programmes typically cover both fundamentals and advanced topics, including Playbooks, Roles, Loops, Conditionals, Inventory management, and integration with tools such as Vagrant. That breadth of coverage makes a structured course a useful shortcut compared to purely self-directed learning.

1. Access to High-Paying DevOps Roles

DevOps engineers who can demonstrate automation skills — particularly around configuration management and infrastructure provisioning — consistently command competitive salaries in the tech job market. Ansible proficiency is a commonly listed requirement in DevOps, Site Reliability Engineering (SRE), and Platform Engineering job postings.

Because Ansible covers configuration management, provisioning, and deployment in a single tool, a practitioner who knows it well can take ownership of large portions of the automation pipeline. That scope of responsibility translates directly into stronger negotiating leverage when discussing compensation or promotion.

2. Increased Personal and Team Productivity

Repetitive manual tasks — patching servers, deploying releases, configuring new environments — are a significant drain on engineering time. Ansible lets you define those tasks once in a playbook and execute them reliably across any number of hosts. Common productivity wins include:

• Consistent environment setup that eliminates “works on my machine” problems.
• Parallel execution across large server fleets without proportionally more effort.
• Automated provisioning of IoT devices or cloud instances at scale.
• Reduced infrastructure management overhead, freeing budget and time for higher-value work.

When you can demonstrate measurable time savings through automation, that contribution is visible to leadership — which directly supports career progression.

3. Leverage a Large, Active Open-Source Community

Ansible is one of the most active open-source projects in the infrastructure automation space. A large community means a wealth of publicly available roles on Ansible Galaxy, active forums, detailed documentation, and a broad base of colleagues and mentors to learn from.

For someone early in their automation career, this community effect is significant. Rather than building everything from scratch, you can study well-maintained community roles, contribute improvements, and build a public portfolio that is visible to potential employers. Active community participation also keeps your skills current as the tooling evolves.

4. Agentless Architecture Lowers the Barrier to Adoption

Unlike some automation tools that require an agent process running on every managed node, Ansible communicates over SSH (or WinRM for Windows hosts). There is nothing to install on target servers before you can manage them. This agentless design has several practical career implications:

• Fast time to value: You can demonstrate results in an organisation quickly, without a lengthy bootstrapping phase.
• Easier adoption: Security and operations teams are often more comfortable granting SSH access than approving a persistent agent binary.
• Simpler troubleshooting: Fewer moving parts means fewer failure modes to diagnose.

Being able to introduce automation with minimal organisational friction is a skill in itself — and one that makes an Ansible practitioner visibly useful in almost any IT environment.

5. Low Learning Curve, High Practical Ceiling

Ansible playbooks are written in YAML, a human-readable format that does not require deep programming experience to get started. An IT professional comfortable with the command line can typically write and run a basic playbook within a day. That low entry barrier means:

• You can apply Ansible skills quickly on real projects rather than spending months on theory.
• System administrators without a software development background can automate tasks that previously required scripting expertise.
• The same playbook logic scales from managing a single server to hundreds with no structural change.

The ceiling is equally high. Advanced practitioners use Ansible with dynamic inventory, custom modules written in Python, complex Jinja2 templating, and integration into CI/CD pipelines — providing a clear path for continued skill growth long after the basics are mastered.

Going Further: Ansible Automation Platform

Red Hat’s Ansible Automation Platform (which includes the controller previously known as Ansible Tower) provides a graphical interface, role-based access control, scheduling, and centralised logging on top of core Ansible. Familiarity with the platform is increasingly expected in enterprise DevOps roles, making it a worthwhile extension of foundational Ansible training.

Getting Started

If you are ready to build Ansible skills, look for courses that cover the full workflow: writing playbooks, organising code with Roles, managing inventory, using Variables and Vault for secrets, and integrating Ansible into a CI/CD pipeline. Hands-on labs with real infrastructure — even a local Vagrant or Docker setup — will accelerate learning far more than video content alone.

The combination of broad industry demand, a genuinely approachable learning curve, and deep practical capability makes Ansible one of the higher-return skills available to DevOps and infrastructure professionals today.

What Is DevOps and Why Does the Career Path Look Different?

DevOps emerged as a direct response to the chronic friction between siloed Development and IT Operations departments. When these two groups work in isolation, handoffs break down, deployments become risky events, and accountability for the health of the product gets diffuse. DevOps tears down those silos by establishing shared ownership of the full software delivery lifecycle — from code commit to production monitoring.

The rise of cloud computing and software-defined infrastructure (virtual servers, software-defined storage, infrastructure-as-code) has accelerated the adoption of DevOps practices, making cross-disciplinary skills more valuable than ever. A DevOps engineer therefore needs a working command of both traditional operations concepts and modern development tooling.

Recommended Formal Certification Pathway

The list below is ordered to build knowledge progressively — start with networking and server fundamentals before moving into cloud platforms and advanced architecture topics. A strong foundation in core infrastructure makes cloud and DevOps concepts far easier to absorb.

1. CompTIA Network+ — establishes essential networking knowledge that underpins every cloud and on-premises environment.
2. Microsoft MCSA: Windows Server — builds server administration skills relevant to hybrid and Windows-centric environments.
3. AWS Technical Essentials — provides a vendor-neutral introduction to core AWS services and cloud concepts.
4. LPI LPIC-1 / CompTIA Linux+ — Linux is the dominant OS in cloud and container environments; these entry-level credentials confirm your command-line fluency.
5. MCSD: Azure Solutions Architect — validates the ability to design and implement solutions on Microsoft Azure.
6. AWS Certified Solutions Architect – Associate — one of the most widely recognised cloud credentials; demonstrates the ability to design resilient, cost-effective AWS architectures.
7. LPI LPIC-2 — advances Linux skills into multi-system administration and enterprise-grade configurations.
8. AWS Certified SysOps Administrator – Associate — focuses on deployment, management, and operations of workloads on AWS.
9. Microsoft MCSE: Private Cloud — covers on-premises and hybrid cloud infrastructure management with Microsoft technologies.
10. Google Cloud Platform Fundamentals — introduces GCP services and architecture; note that Google periodically revises its certification portfolio, so verify current exam names before enrolling.
11. Google Cloud: Associate Cloud Engineer or Professional Cloud Developer — more advanced GCP credentials for those working primarily on the Google platform.

Important: Google has revised its certification structure since this pathway was first published. Always check the official Google Cloud certification page for the current list of available exams before planning your study schedule.

Critical Skills and Tools (With or Without a Formal Certification)

Several of the most important DevOps competencies do not map neatly to a vendor certification — or the available certifications lag behind the market. Treat the following areas as mandatory learning regardless of whether you sit a formal exam:

• Docker and container fundamentals — containers are the atomic unit of modern application deployment; understanding images, registries, networking, and volumes is non-negotiable.
• Configuration management with Chef or Puppet — these tools automate infrastructure provisioning and enforce consistent state across fleets of servers. Learning either (or both) gives you practical experience with infrastructure-as-code principles.
• PowerShell scripting — essential for automating Windows Server and Azure tasks; PowerShell is increasingly cross-platform.
• Python programming — the scripting language of choice for automation, tooling, and a wide range of DevOps utilities including Ansible playbooks and AWS Lambda functions.
• JavaScript frameworks (AngularJS, ReactJS) — DevOps engineers who understand the front-end build pipeline can collaborate more effectively with development teams and debug CI/CD pipeline issues faster.
• Java essentials — many enterprise applications are Java-based; understanding the build and packaging process (Maven, Gradle, JAR/WAR files) helps when building deployment pipelines.

Advice for New DevOps Professionals

Historically, most IT professionals arrived in DevOps roles by accident — a sysadmin who learned scripting, or a developer pressed into managing production systems. Today, you can take a more deliberate route. The key attributes that define a successful DevOps career are:

• Commitment to continuous learning. The tooling, practices, and platforms in this space evolve faster than in almost any other IT discipline. Staying current is not optional.
• Breadth alongside depth. DevOps requires you to understand networking, servers, cloud platforms, scripting, and software delivery processes. Specialise where you can, but maintain working knowledge across all these domains.
• A culture of shared responsibility. DevOps is as much a cultural shift as a technical one. Internalise the idea that everyone on the team is accountable for the reliability and quality of the product in production.
• Hands-on practice. Certifications demonstrate knowledge; practical projects demonstrate competence. Build pipelines, run containers, automate infrastructure, and break things safely in a lab environment.

Planning Your Next Steps

Start with networking and Linux fundamentals if you do not already have a solid operations background. Layer in a cloud platform — AWS is the largest by market share, making it a pragmatic first choice — then build upward toward architecture-level certifications. Simultaneously, invest time in containers, configuration management, and at least one scripting language.

DevOps rewards engineers who treat their career as a product: iterate frequently, gather feedback from the market (job postings, community forums, conference talks), and continuously refine your skills. The engineers who thrive in this space are those who genuinely enjoy the act of learning.

This article draws on guidance originally published by CBT Nuggets. Certification names, exam structures, and vendor portfolios change regularly — always verify current requirements directly with the certifying body before committing to a study path.