DEV Community: Jeremy King

How I Cleared Microsoft AI-103 in Just One Week

Jeremy King — Mon, 22 Jun 2026 09:35:10 +0000

When I first booked my Microsoft AI-103 exam, I honestly wasn't sure if one week would be enough.

AI-103 (Designing and Implementing a Microsoft Azure AI Solution) covers a wide range of Azure AI services, from Azure AI Vision and Language to Azure OpenAI Service, AI Search, and responsible AI practices. While I had some experience working with Azure and AI concepts, I had never studied specifically for this certification.

With only seven days available before exam day, I decided to focus on high-impact learning rather than trying to consume every resource I could find.

Here's exactly what I did.

Day 1: Understand the Exam Objectives

The first thing I did was review the official Microsoft skills outline.

This helped me identify the major domains covered in the exam:

Azure AI Vision
Azure AI Language
Azure AI Speech
Azure AI Search
Azure OpenAI Service
Knowledge Mining
Responsible AI
Solution Design and Integration

Instead of immediately jumping into practice questions, I wanted to understand what Microsoft expected candidates to know.

This prevented me from wasting time studying topics that were unlikely to appear on the exam.

Days 2-3: Microsoft Learn

Most of my preparation started with Microsoft Learn.

The learning paths are free, well-structured, and closely aligned with the exam objectives.

I focused on:

Azure AI Services
Azure OpenAI Service
AI Search
Language Understanding
Computer Vision
Speech Services

One thing I noticed is that AI-103 isn't purely theoretical.

Microsoft expects candidates to understand how services are configured, integrated, secured, and monitored in real-world solutions.

While reading, I took notes on:

Service capabilities
Authentication methods
Pricing considerations
Deployment options
Common use cases

Days 4-5: Hands-On Practice

Reading documentation is important, but AI-103 contains many scenario-based questions.

To reinforce what I learned, I spent time reviewing sample implementations and practicing with Azure services whenever possible.

I focused on understanding:

When to use Azure AI Search versus Azure OpenAI
How Cognitive Services are secured
Data ingestion workflows
Responsible AI requirements
Monitoring and troubleshooting

This was the stage where concepts started connecting together.

Day 6: Practice Questions and Weak Areas

By Day 6, I felt comfortable with most of the content, but I still had gaps.

Practice questions helped me identify areas that needed more attention.

I used a combination of study materials, practice questions, and mobile review tools to test my understanding of key concepts.

For short study sessions during breaks, I occasionally used Revizo on my phone. I found it useful for quick knowledge checks and reviewing concepts when I wasn't sitting at my desk. Most of my learning still came from Microsoft Learn and hands-on review, but having a mobile option helped me make use of small pockets of time throughout the day.

Rather than focusing on scores, I paid close attention to explanations behind incorrect answers.

This turned out to be one of the most effective parts of my preparation.

Day 7: Final Review

The day before the exam, I stopped trying to learn new topics.

Instead, I reviewed:

My notes
Microsoft Learn summaries
Frequently missed concepts
Service limitations and capabilities

I also reviewed architecture scenarios involving:

Azure AI Search
Azure OpenAI Service
Language Services
Vision Services

The goal was reinforcement, not cramming.

Exam Day Experience

The actual exam felt fair but challenging.

Many questions were scenario-based and required understanding how multiple Azure AI services work together.

A few lessons stood out:

Read every requirement carefully.
Eliminate technically correct but suboptimal answers.
Pay attention to security, scalability, and cost considerations.
Understand the differences between similar services.

I found that practical understanding mattered more than memorization.

Resources I Used

These were the resources that contributed the most to my preparation:

Resource	Purpose
Microsoft Learn	Primary learning resource
Azure Documentation	Service-specific details
Hands-on Azure Practice	Understanding real-world implementation
Practice Questions	Identifying weak areas
Revizo (iOS)	Quick mobile review sessions during downtime

If I had to choose only one resource, it would be Microsoft Learn. The content is directly aligned with Microsoft's expectations and provides an excellent foundation for the exam.

Final Thoughts

Can someone pass AI-103 in a week?

I think it's possible if you already have some familiarity with Azure and can dedicate focused study time each day.

The key isn't finding a shortcut. It's concentrating on the exam objectives, understanding how Azure AI services fit together, and spending time reviewing your weak areas.

For me, one focused week was enough.

If you're preparing for AI-103, my advice is simple: start with Microsoft Learn, reinforce concepts through practice, and focus on understanding the "why" behind each service rather than memorizing facts.

Good luck with your exam preparation!

OpenClaw Basic Configuration: A Practical Starter Guide

Jeremy King — Sat, 20 Jun 2026 22:57:10 +0000

OpenClaw is easiest to understand if you treat it as a local-first control plane for an AI assistant. The model is only one part of the system. The real behavior comes from the gateway, the channels you expose, the tools you allow, the workspace you give it, and the safety boundaries around all of that.

This is a practical pass through the basic configuration I would check before calling an OpenClaw setup "ready enough to use."

1. Start with onboarding unless you have a reason not to

For a new install, the recommended path is still:

openclaw onboard --install-daemon

The onboarding flow handles the boring but important parts: choosing a model provider, storing auth, configuring the gateway, and getting a first usable session running. After that, you can inspect and refine the generated config instead of writing everything from scratch.

That is the right order. Let the tool create a valid baseline, then edit deliberately.

2. Know where the config lives

OpenClaw reads an optional JSON5 config from:

~/.openclaw/openclaw.json

You can point OpenClaw somewhere else with:

OPENCLAW_CONFIG_PATH=/path/to/openclaw.json

The important detail: OpenClaw validates config strictly. Unknown keys, wrong types, or invalid values can stop the gateway from starting. That sounds fussy, but it is a useful guardrail for an agent that may be connected to real accounts and real tools.

A tiny config might look like this:

{
  agents: {
    defaults: {
      workspace: "~/.openclaw/workspace"
    }
  },
  channels: {
    telegram: {
      enabled: true,
      dmPolicy: "pairing"
    }
  }
}

3. Use the CLI for small config edits

For one-off changes, prefer the config CLI over opening the file manually:

openclaw config get agents.defaults.workspace
openclaw config set agents.defaults.heartbeat.every "2h"
openclaw config unset plugins.entries.brave.config.webSearch.apiKey

For larger edits, direct editing is fine, but validate immediately:

openclaw config validate
openclaw doctor

If the gateway refuses to start after a config change, openclaw doctor is the first command I would run.

4. Pick a primary model and define fallbacks

Model configuration is usually under agents.defaults.model.

{
  agents: {
    defaults: {
      model: {
        primary: "anthropic/claude-sonnet-4-6",
        fallbacks: ["openai/gpt-5.4"]
      },
      models: {
        "anthropic/claude-sonnet-4-6": { alias: "Sonnet" },
        "openai/gpt-5.4": { alias: "GPT" }
      }
    }
  }
}

The convention is provider/model. If you define agents.defaults.models, that list becomes an allowlist for model selection. That is useful in team or multi-agent setups, but it can surprise you later when /model some-new-model fails because the model is not on the allowlist.

My rule of thumb:

Use a strong primary model for tool-enabled agents.
Add one or two fallbacks for reliability.
Avoid weak models for agents that read untrusted messages or operate real tools.

5. Lock down who can message the bot

This is the configuration area I would not skip.

Each channel has its own section, such as:

{
  channels: {
    telegram: {
      enabled: true,
      botToken: "${TELEGRAM_BOT_TOKEN}",
      dmPolicy: "pairing",
      allowFrom: []
    }
  }
}

The common DM policies are:

pairing: unknown senders get a pairing code before they can interact.
allowlist: only approved senders can talk to the bot.
open: anyone can message it, and this should be rare.
disabled: DMs are ignored.

For a personal assistant, pairing is a sane default. For a public or team-facing channel, be much more explicit. The bot is not just chat UI; it may have tools behind it.

6. Treat sessions as part of privacy

Session configuration controls how conversation state is shared or isolated.

{
  session: {
    dmScope: "per-channel-peer",
    threadBindings: {
      enabled: true,
      idleHours: 24,
      maxAgeHours: 0
    },
    reset: {
      mode: "daily",
      atHour: 4,
      idleMinutes: 120
    }
  }
}

For single-user local experiments, a broad shared session can be convenient. For anything involving multiple people, channels, or accounts, isolate more aggressively. per-channel-peer is a good starting point because it avoids one person's context bleeding into another person's conversation.

7. Enable sandboxing before the agent meets messy inputs

OpenClaw can run tools with significant host access. That is powerful, and also exactly why sandboxing matters.

A basic sandbox posture:

{
  agents: {
    defaults: {
      sandbox: {
        mode: "non-main",
        scope: "agent"
      }
    }
  }
}

The practical interpretation:

off: no sandboxing.
non-main: keep the trusted main session direct, sandbox other sessions.
all: sandbox everything.

If you are connecting group chats, webhooks, public channels, or feeds that may contain prompt injection, prefer stricter isolation. The more untrusted the input, the smaller the tool surface should be.

8. Keep secrets out of plain config when possible

OpenClaw reads environment variables from the parent process, a local .env, and ~/.openclaw/.env. You can reference env vars in config strings:

{
  gateway: {
    auth: {
      token: "${OPENCLAW_GATEWAY_TOKEN}"
    }
  },
  channels: {
    telegram: {
      botToken: "${TELEGRAM_BOT_TOKEN}"
    }
  }
}

That is better than hardcoding tokens into a config file you might sync, back up, or paste into a ticket. For more advanced setups, OpenClaw also supports secret references through env, file, and exec-backed providers.

9. Use hot reload, but know its limits

The gateway watches ~/.openclaw/openclaw.json and can hot-apply many changes. Agent, model, channel, tool, session, cron, and logging changes are generally designed to apply without a full manual restart.

Gateway server settings are different. Port, bind address, TLS, auth, and similar gateway-level changes may require restart behavior.

So the habit is:

openclaw config validate
openclaw gateway status
openclaw doctor

If you changed a networking or auth-related setting, expect a restart to be involved.

10. A starter checklist

Before using OpenClaw for anything real, I would check:

openclaw onboard --install-daemon has completed successfully.
openclaw gateway status reports the gateway is running.
The primary model and fallbacks are configured.
Each channel has a deliberate dmPolicy.
Group chats require mention unless you truly want always-on behavior.
Multi-user setups use isolated session scope.
Sandbox mode is enabled for non-main or untrusted sessions.
Secrets come from env vars or secret refs, not pasted tokens.
openclaw doctor is clean.

The theme is simple: configure OpenClaw like an assistant with hands, not like a chatbot with text. Once it can touch tools, accounts, files, or other people, basic configuration becomes part of your safety model.

References:

OpenClaw GitHub README: https://github.com/openclaw/openclaw
Getting started: https://docs.openclaw.ai/start/getting-started
Gateway configuration: https://docs.openclaw.ai/gateway/configuration
Models CLI: https://docs.openclaw.ai/concepts/models

How I Passed AWS SAP-C02 in Just 3 Days

Jeremy King — Sat, 20 Jun 2026 22:46:24 +0000

When I tell people I passed the AWS Certified Solutions Architect – Professional (SAP-C02) exam after only three days of preparation, the first reaction is usually:

"There's no way you learned SAP-C02 in three days."

And they would be right.

I didn't start from zero.

I already had several years of hands-on AWS experience and had previously passed SAA-C03. What I needed wasn't months of learning AWS services—it was three days of focused exam preparation to bridge the gap between real-world experience and AWS's exam style.

This article explains exactly what I used and what worked for me.

Day 0: Understanding What SAP-C02 Really Tests

One mistake I see many candidates make is treating SAP-C02 like a harder version of SAA.

It's not.

The exam is heavily focused on:

Multi-account architectures
AWS Organizations
Hybrid connectivity
Migration strategies
Disaster recovery
Cost optimization at scale
Complex networking scenarios
Security and governance

The questions are long.

Very long.

In many cases, the challenge isn't knowing the service. It's identifying the best architectural trade-off among several technically correct answers.

After reading through multiple Reddit success stories, one common theme stood out:

SAP-C02 is as much a reading-comprehension and architecture exam as it is an AWS knowledge exam.

I quickly realized that practice questions would be the key.

Day 1: Focused Theory Review

Instead of watching a 50+ hour course from start to finish, I reviewed only the topics where I felt weak.

The resources I used were:

AWS Documentation

I spent several hours reviewing:

AWS Organizations
Control Tower
Transit Gateway
Direct Connect
Site-to-Site VPN
Route 53 routing policies
Disaster Recovery patterns
Migration services

The AWS documentation remains the most reliable source when you're unsure about service limitations or implementation details.

Stephane Maarek's SAP-C02 Course

I didn't watch the entire course.

Instead, I jumped directly to:

Hybrid networking
Security
Organizations
Migration
Cost optimization

Many SAP-C02 candidates on Reddit consistently recommend Stephane's course as a strong foundation resource, especially when paired with practice exams.

Day 2: Practice Questions, Practice Questions, Practice Questions

This was easily the most important day.

If I had to credit one factor for passing, it would be practice exams.

Tutorials Dojo

I completed multiple timed and review-mode practice exams.

What I liked:

Questions are scenario-based
Detailed explanations
Explanations often teach more than the questions themselves
Difficulty is reasonably close to the real exam

Many SAP-C02 pass posts on Reddit mention Tutorials Dojo as their primary exam preparation tool, especially for getting used to long-form architectural scenarios.

My scores were not amazing initially.

I was averaging around 65–75%.

Instead of worrying about the score, I focused on understanding why I got questions wrong.

That review process was where most of the learning happened.

Day 3: Mobile Revision and Weak Areas

By the third day, I didn't want to sit at my desk anymore.

I switched to shorter review sessions throughout the day.

For quick practice sessions on my phone, I used a few different question sources, including Revizo on iOS.

What I liked about using a mobile practice engine:

Easy to review during breaks
Quick quiz sessions
Useful for reinforcing concepts repeatedly
Helps build familiarity with AWS terminology

I wouldn't rely on any single question bank alone, but having something available on my phone made it easier to squeeze in extra revision time when I wasn't at my computer.

At this stage, I wasn't trying to learn new topics.

I was simply identifying recurring mistakes and reinforcing weak areas.

Exam Day Experience

The biggest surprise wasn't the technical difficulty.

It was the mental stamina required.

SAP-C02 contains lengthy scenarios and answer choices.

Several times I narrowed questions down to two seemingly correct answers and had to choose the option that best aligned with AWS architectural best practices.

Topics that appeared frequently included:

AWS Organizations
Multi-account governance
Hybrid networking
Migration
Resiliency
Security controls
Cost optimization

Time management was critical.

If you're preparing for SAP-C02, I strongly recommend doing full-length practice exams under timed conditions before attempting the real exam.

What I Would Do Again

If I had only three days to prepare again, I would follow almost exactly the same strategy:

1. Review Weak AWS Services

Don't try to relearn everything.

Focus on areas that regularly appear in SAP-C02:

Organizations
Control Tower
Direct Connect
Transit Gateway
Route 53
DR strategies

2. Prioritize Practice Exams

Practice exams provide the highest return on investment.

For me, Tutorials Dojo delivered the most value.

3. Review Every Incorrect Answer

The explanation is often more important than the score.

4. Use Mobile Study Time

Whether it's flashcards, notes, or a practice app like Revizo, small review sessions throughout the day add up surprisingly quickly.

Final Thoughts

Could a complete beginner pass SAP-C02 in three days?

Absolutely not.

Could someone with solid AWS experience pass in three focused days?

Yes.

SAP-C02 is less about memorizing services and more about understanding architectural trade-offs at scale.

If you already work with AWS regularly, focus your preparation on practice exams, identify your weak areas, and spend your time reviewing explanations rather than chasing perfect scores.

That's exactly what worked for me.

And three days later, I walked away with a pass.