Forem

Techn0tz Turns 1 — Help Shape What’s Next

manjushaps — Sat, 18 Apr 2026 05:07:16 +0000

Techn0tz turns 1 🎉

It started as a simple space to document learning.

Over time, it evolved into building real applications in Rust — focusing on how things work, not just how to write them.

The next phase moves toward deeper features and more structured learning.

To make this more useful, a quick survey has been added:

👉 Takes less than 1 minute ⏱️
🔗 Open 1-Minute Survey

Your input will directly influence what comes next.

💬 Feedback is welcome.

AWS Data & AI Stories #02: Amazon Bedrock Data Automation

Sedat SALMAN — Sat, 18 Apr 2026 05:01:56 +0000

In the first article, I talked about multimodal AI at a high level.

Now it is time to go one step deeper.

When we say multimodal AI, one of the first real challenges is not the model itself. The first challenge is the data. In most environments, the input is messy, unstructured, and spread across different formats such as documents, images, audio, and video. Amazon Bedrock Data Automation, or BDA, is designed for exactly this problem: extracting useful insights from unstructured multimodal content and turning it into structured output that applications can use.

For me, BDA is not the “chat” layer. It is the processing layer.

That is what makes it important.

What is Amazon Bedrock Data Automation?

Amazon Bedrock Data Automation is a managed AWS capability that automates insight generation from unstructured content such as documents, images, audio, and video. Instead of building separate extraction pipelines for each format, you can use BDA to generate structured outputs from multimodal input in a more consistent way.

This is useful because many AI projects fail at the beginning.

Not because the model is weak, but because the source data is not ready.

Think about a few common examples:

scanned PDFs
invoices
screenshots
call recordings
inspection videos
photos from the field
reports with mixed text and visuals

These are all valuable, but none of them are naturally clean inputs for downstream AI.

Why does BDA matter?

Because AI systems need structure.

Before you build search, RAG, analytics, or assistants, you usually need to answer a simpler question:

How do I turn raw content into usable information?

That is where BDA fits.

AWS describes BDA as a service that can produce both standard output and custom output depending on the use case. Standard output gives predefined insights for a data type, while custom output lets you define tailored extraction logic. This makes BDA useful not only for generic processing, but also for business-specific workflows.

So in practical terms, BDA can help when you want to:

extract content from complex documents
summarize audio or video
generate structured metadata
prepare content for retrieval
feed another AI workflow

How I would position BDA in an AWS architecture

I would place BDA near the beginning of the workflow.

A simple view looks like this:

Input data → BDA processing → structured output → storage/indexing → retrieval/generation

This is also how AWS examples position it. In AWS guidance and solution examples, BDA is commonly used after content lands in S3, and before services such as Knowledge Bases, vector stores, or agentic applications use the extracted results.

So if Part 1 was about multimodal AI, Part 2 is about making multimodal content usable.

Main concepts to understand

There are two core ideas in BDA that matter most: projects and blueprints.

1. Projects

A project is the main configuration container in BDA. AWS documentation describes it as the grouping that holds standard and optional custom output settings for processing. When you call the async API with a project ARN, BDA uses that project’s configuration to process the file and produce the defined outputs.

In simple terms, a project is where you define how BDA should behave for your use case.

2. Blueprints

Blueprints are what make custom extraction possible. AWS documentation explains that blueprints define the extraction logic and output format for custom outputs, allowing you to tailor BDA to your own business fields and data structures.

This is one of the most valuable parts of BDA.

Because in real projects, we usually do not want only generic output. We want specific fields, specific structure, and specific business meaning.

For example:

invoice number
customer name
incident category
equipment ID
inspection result
priority level

That is where blueprints become important.

Standard output vs custom output

This is one of the most important design choices.

Standard output

Standard output is faster to start with. AWS says it provides predefined insights based on the data type being processed, such as document semantics, audio transcripts, or video summaries and chapter summaries.

This is a good option when:

you want speed
you are validating a use case
you do not need very specific extraction fields yet

Custom output

Custom output is for more targeted use cases. With blueprints, you define the extraction logic and expected structure so the output matches your business need more closely. AWS has also added features such as blueprint instruction optimization to improve custom extraction accuracy using example assets and ground-truth labels.

This is a better option when:

you need specific fields
you need consistency
you are building a production workflow
your documents or media are domain-specific

For me, the normal journey is:
start with standard output, then move to custom output when the use case becomes clearer.

What types of content can BDA process?

BDA is built for multimodal content. AWS documentation and product pages describe support for:

documents
images
audio
video

That matters because many organizations have all four.

And the value is not only in “understanding” each file type independently. The real value is creating a single processing layer for all of them.

Where BDA fits best

I think BDA is strongest in these scenarios:

1. Intelligent document processing

AWS has positioned BDA strongly for document-heavy workflows, and AWS blog content around intelligent document processing shows it being used to accelerate extraction and automation for business documents.

Preparing content for RAG

AWS examples show BDA being used before Knowledge Bases and vector indexing so that multimodal content can be turned into cleaner, more useful retrieval input.

3. Audio and video understanding

BDA can generate outputs such as transcripts and summaries from audio and video, and AWS recently expanded it with custom vocabulary support through Data Automation Library to improve speech recognition accuracy for domain-specific terms.

4. Compliance and content review

AWS has also shown BDA in workflows such as extracting attachment content for later PII detection and redaction with Guardrails, which makes it relevant beyond simple summarization.

A practical workflow example

Let’s take a simple example.

Imagine you are building a support or operations workflow.

The input may include:

a maintenance PDF
a photo from the field
a voice note from an engineer
a short inspection video

Without a processing layer, each file stays isolated.

With BDA, the system can extract usable outputs from these files, and the rest of the architecture can work with those results more easily. Those extracted outputs can then be stored, indexed, sent to a knowledge base, or used by an agentic workflow. This is consistent with AWS’s documented BDA flow and solution examples that combine S3, BDA, Knowledge Bases, OpenSearch, and AgentCore.

That is why I see BDA as the bridge between raw content and usable AI workflows.

Newer capabilities worth watching

Two additions make BDA more interesting for real projects.

First, AWS added blueprint instruction optimization, which helps improve custom field extraction accuracy using example documents and labels. This is useful because custom extraction often needs tuning before it becomes reliable.

Second, AWS added custom vocabulary through Data Automation Library for audio and video processing. This helps when your environment uses domain-specific terms, product names, or technical language that general transcription may miss.

These are good signs that BDA is moving from “interesting feature” toward “serious processing layer.”

Things to keep in mind

BDA is powerful, but I would still keep a few points in mind.

1. Start simple

AWS recommends starting with standard output if you are new to the service. That makes sense because it helps validate the value quickly before you invest in custom extraction logic.

2. Design for the business output

Do not begin with “what model do I want?”
Begin with:

what fields do I need?
what decision will use this output?
what system will consume it?

3. Watch input requirements

AWS documents prerequisites and file requirements for BDA, including file-specific constraints that differ by content type and processing mode.

4. Treat prompts and blueprints carefully

AWS explicitly notes that blueprint prompt input should come from trusted sources, which is an important reminder for secure enterprise design.

Final thoughts

For me, Amazon Bedrock Data Automation is one of the most practical pieces in the current AWS multimodal stack.

It does not replace retrieval, RAG, or agents.

It enables them.

If multimodal AI is the bigger vision, BDA is one of the first services that helps turn that vision into a usable workflow. It helps convert raw documents, images, audio, and video into outputs that the rest of your architecture can actually work with.

That is why I would not treat BDA as a side feature.

I would treat it as a foundational building block.

In the next article, I will move one step further and focus on multimodal knowledge bases and how retrieval fits after the processing layer.

Kubernetes v1.36 Drops April 22: What Platform Engineers Actually Need to Know

Mateen Anjum — Sat, 18 Apr 2026 04:54:58 +0000

TL;DR: Kubernetes v1.36 releases April 22, 2026. The headline features are DRA GPU partitioning, workload-aware preemption for AI/ML jobs, and the permanent removal of the gitRepo volume plugin. Ingress-nginx is also officially retired. If you run AI inference workloads or care about cluster security, this release is not optional reading.

Why This Release Matters More Than Most

The CNCF's 2025 annual survey dropped a number that stopped a lot of people mid-scroll: 66% of organizations hosting generative AI models now use Kubernetes for some or all of their inference workloads. That's not a trend, that's a fait accompli. Kubernetes is the AI compute substrate whether you planned for it or not.

v1.36 is the release that leans into that reality. The bulk of the new work is in Dynamic Resource Allocation (DRA), gang scheduling, and topology-aware placement, all of which exist because running distributed AI/ML jobs on Kubernetes has historically been painful. This release makes it less painful.

But there are also breaking changes and security fixes that affect everyone, not just the ML crowd. Let me walk through what actually matters.

The Breaking Changes First

gitRepo Volume Plugin: Gone for Good

If you're still using gitRepo volumes, stop reading and go fix that right now. The plugin has been deprecated since v1.11 and is now permanently disabled in v1.36. No feature flag, no workaround.

The reason it's gone is serious: gitRepo allowed attackers to run code as root on the node. It was a known attack vector for years. The right replacement is an init container running git clone, or a git-sync sidecar. Both are well-documented and production-proven.

# Before (broken in v1.36)
volumes:
  - name: code
    gitRepo:
      repository: "https://github.com/example/repo"
      revision: "main"

# After: use an init container
initContainers:
  - name: git-sync
    image: registry.k8s.io/git-sync/git-sync:v4.2.1
    args:
      - --repo=https://github.com/example/repo
      - --branch=main
      - --root=/git
      - --one-time
    volumeMounts:
      - name: code
        mountPath: /git

Ingress-NGINX Is Retired

SIG Network and the Security Response Committee retired ingress-nginx on March 24, 2026. No more releases, no more security patches. Existing deployments keep running, but you're on your own for CVEs from here.

The community's recommended alternatives are Envoy Gateway (CNCF graduated), Cilium Gateway API, and Traefik. If you're on ingress-nginx in production, this is your migration window. Don't wait for the next CVE to force your hand.

service.spec.externalIPs Deprecated

The externalIPs field in Service specs is being deprecated (full removal planned for v1.43). It's been a known vector for man-in-the-middle attacks since CVE-2020-8554. You'll see deprecation warnings starting in v1.36. Migrate to LoadBalancer services, NodePort, or Gateway API.

The AI/ML Features That Actually Change How You Work

DRA: Partitionable Devices (Beta)

This is the one I'm most excited about. v1.36 promotes DRA support for partitionable devices to beta, meaning it's enabled by default. A single GPU can now be split into multiple logical units and allocated to different workloads.

Before this, if you had an H100 and a workload that only needed 20% of it, you either wasted 80% or ran a separate MIG configuration outside Kubernetes. Now the scheduler handles it natively.

apiVersion: resource.k8s.io/v1beta1
kind: ResourceClaim
metadata:
  name: partial-gpu
spec:
  devices:
    requests:
    - name: gpu-slice
      deviceClassName: nvidia.com/gpu
      count: 1
      # Request a partition, not the whole device
      selectors:
      - cel:
          expression: device.attributes["nvidia.com/gpu"].partitionable == true

For platform teams running shared GPU clusters, this is a significant cost lever. You can pack more inference workloads onto the same hardware without sacrificing isolation.

Workload-Aware Preemption (Alpha)

Standard Kubernetes preemption works pod-by-pod. For distributed AI/ML jobs, that's a disaster: preempt one pod from a training job and the whole job stalls, wasting all the resources it's still holding.

v1.36 introduces workload-aware preemption via PodGroups. The scheduler now treats a group of related pods as a single entity. When it needs to make room for a high-priority job, it preempts entire groups rather than individual pods.

apiVersion: scheduling.k8s.io/v1alpha1
kind: PodGroup
metadata:
  name: training-job-a
spec:
  minMember: 8
  priorityClassName: high-priority
  gangSchedulingPolicy:
    disruptionMode: PodGroup  # preempt the whole group, not individual pods

This is alpha, so it's off by default. But if you're running Kueue or JobSet for batch AI workloads, this is worth enabling in a test cluster now.

Pod-Level Resource Managers (Alpha)

For HPC and AI/ML workloads, NUMA alignment matters. Previously, the Topology Manager only worked at the container level. If you had a training container plus logging and monitoring sidecars in the same pod, you couldn't guarantee they all landed on the same NUMA node.

v1.36 adds pod-scope resource management: you can now set pod.spec.resources and have the Topology Manager treat the entire pod as a single scheduling unit. All containers get resources from the same NUMA node.

spec:
  resources:
    requests:
      cpu: "16"
      memory: "64Gi"
  topologySpreadConstraints:
    - maxSkew: 1
      topologyKey: topology.kubernetes.io/numa-node
      whenUnsatisfiable: DoNotSchedule

DRA Resource Availability Visibility (Alpha)

Finally, a native way to answer "how many GPUs are free in this cluster?" without writing custom tooling.

kubectl create -f - <<EOF
apiVersion: resource.k8s.io/v1alpha1
kind: ResourcePoolStatusRequest
metadata:
  name: check-gpus
spec:
  driver: nvidia.com/gpu
EOF

kubectl get rpsr/check-gpus -o yaml
# Returns: totalDevices, allocatedDevices, availableDevices per node

This is alpha, but it's the kind of operational visibility that platform teams have been hacking around for years.

The Stability Improvements

SELinux Volume Labeling: Now GA

Faster pod startup on SELinux-enforcing systems. This replaces recursive file relabeling with a single mount-time label, which can cut pod startup time significantly on large volumes. It's been in beta since v1.28 and is now stable and on by default.

If you're running RHEL or any SELinux-enforcing OS, you'll notice this immediately.

External ServiceAccount Token Signing: GA

The kube-apiserver can now delegate token signing to external KMS or HSM systems. For clusters with strict key management requirements (financial services, healthcare, government), this removes a significant compliance gap.

Graceful Leader Transition (Alpha)

Control plane components (kube-controller-manager, kube-scheduler) used to call os.Exit() when losing leader election, forcing a full restart. v1.36 introduces graceful transitions: the component moves to follower state and re-enters the election without restarting. Faster failover, less noise in your control plane logs.

Stale Controller Mitigation (Alpha)

Large clusters with high churn have always had a subtle bug: a controller creates a resource, its cache hasn't updated yet, and it tries to create the same resource again. v1.36 adds cache freshness tracking so controllers check whether their local state is current before reconciling. Fewer duplicate creates, fewer spurious errors in busy clusters.

HPA Scale-to-Zero (Alpha)

The Horizontal Pod Autoscaler can now scale deployments to zero replicas based on external metrics (queue depth, custom metrics). When the queue is empty, the deployment goes to zero. When work arrives, it scales back up. This is the missing piece for event-driven workloads that don't need to run 24/7.

What to Do Before April 22

Audit gitRepo volumes. Run kubectl get pods -A -o json | jq '.items[].spec.volumes[]? | select(.gitRepo != null)'. If you get output, you have work to do.
Plan your ingress-nginx migration. Check kubectl get ingressclass and kubectl get pods -A | grep ingress-nginx. If you're running it, pick a replacement and start testing.
Check for externalIPs usage. kubectl get svc -A -o json | jq '.items[] | select(.spec.externalIPs != null) | .metadata.name'
Enable DRA partitionable devices in staging. If you run GPU workloads, this is worth testing before it becomes the default everywhere.
Read the full changelog. The CHANGELOG-1.36.md is dense but worth scanning for anything specific to your stack.

The Bigger Picture

v1.36 isn't a flashy release. There's no single feature that rewrites how Kubernetes works. What it is, is a release that takes the AI/ML workload story seriously at the scheduler and resource allocation level, while cleaning up years of accumulated security debt.

The gitRepo removal and ingress-nginx retirement are overdue. The DRA work is genuinely new capability. And the gang scheduling improvements are the kind of thing that makes distributed training jobs actually reliable on Kubernetes instead of just theoretically possible.

If you're running AI inference at scale, v1.36 is the release you've been waiting for. If you're running anything else, it's a solid maintenance release with a few security items you can't ignore.

Resources:

I Did 2 Months of Work for a 2-Week Price — Here’s What I learned

Roy Sukro — Sat, 18 Apr 2026 04:54:19 +0000

It started with a simple request.

“Can you build us a website Nothing fancy. Just a clean design, maybe 5 pages. Two weeks, tops.”

I said yes. No contract. No written agreement. Just an email thread with some bullet points and a handshake over Zoom.

You probably know where this is going.

How It Fell Apart

Week one was fine. I designed the homepage, got approval, moved on to the inner pages. Week two is when things started to shift.

“Actually, can you also write the copy for the About page? Just a few paragraphs.”

Sure. That’s not a big deal.

“And can you integrate our booking system? It should be simple — just embed a calendar widget.”

Okay. A bit more work but manageable.

“Oh and the logo doesn’t really match the new site. Can you tweak it a bit?”

I’m a developer, not a designer. But fine.

“One more thing — can you set up basic SEO? Just the meta tags and stuff.”

By week four I was still working on a project that was supposed to be done in two weeks. The client wasn’t being malicious. They genuinely thought all of this was included. And I had nothing — nothing — written down that said it wasn’t.

That project cost me roughly 6 extra weeks of work. Unpaid.

The Real Problem Wasn’t the Client

Here’s the thing I had to admit to myself afterward: it wasn’t the client’s fault.

Clients don’t know what they don’t know. When they hire someone to “build a website,” they imagine a complete, finished, everything-works product. They don’t think in terms of scope. They don’t know that logo design is a separate service, that copywriting is a separate service, that SEO setup is a separate service.

That’s not ignorance — that’s just not being in the industry.

It was my job to define the boundaries. And I didn’t.

The moment I agreed to start work without a clear written document saying exactly what was and wasn’t included, I handed the client a blank check.

What a Statement of Work Actually Does

After that project, I started using a proper Statement of Work for every engagement. Not a general contract — those are about
legal terms and payment conditions. A SOW is project-specific. It answers one question: what exactly are we building together?

A good SOW has a few critical sections:

Scope of Work — what you will do. Specific, detailed, no vague language. Not “design the website” but “design up to 5 pages including Home, About, Services, Portfolio, and Contact.”

What’s Not Included — this is the section that actually changes everything.

Most freelancers write what they will do. Almost nobody writes what they won’t do. But clients fill that gap with assumptions. They assume copywriting is included. They assume revisions are unlimited. They assume the logo is part of the deal.

When you explicitly write “copywriting not included — client
provides all text” and “logo design not included” and “revisions beyond 2 rounds billed at standard hourly rate” — the conversation changes completely.

Not because clients are trying to cheat you. But because now everyone is working from the same page.

Client Responsibilities — what you need from them and when. Content, assets, feedback deadlines. If they’re late providing content, the project timeline shifts. This section protects you from delays that look like your fault.

Kill Fee — if the client cancels after work has started, they owe you a percentage of the total fee. 25% is standard. This protects you from investing weeks into a project that disappears.

Late Payment Clause — unpaid invoices accrue interest. 1.5% per month is standard. Most clients never trigger this — but having it written down means invoices get paid on time.

The Problem With Writing SOWs

Here’s the honest problem: writing a proper SOW from scratch takes 30-60 minutes. Every time. For every project.

You copy the last one, update the client name, try to remember what needs to change, inevitably miss something, send it, have to fix it.

After the scope creep nightmare I described above, I started taking SOWs seriously. But I also got tired of writing them from scratch for every project.

So I built a tool to generate them.

stecya.com — you fill in your project details and AI writes the complete SOW in about 30 seconds. Scope, deliverables, timeline, payment terms, what’s not included, client responsibilities, kill fee — all of it, tailored to your project type.

It’s free to generate and read. I built it because I needed it myself.

What Changed After I Started Using SOWs

The first time I sent a proper SOW to a client, they pushed back a little. “What do you mean copywriting isn’t included?”

I explained. They understood. We added copywriting to the scope, adjusted the price and timeline accordingly. Everyone was happy.

That conversation — which used to happen week three when I was already deep in the project and had no leverage — now happened before a single line of code was written.

That’s the real value of a Statement of Work. It’s not about being difficult or legalistic. It’s about having a real conversation about what you’re building before you build it.

Clients who understand the scope upfront are better clients. Projects with clear boundaries run smoother. And when something outside the scope comes up — and it always does — you have something to point to.

The One Section That Matters Most

If you take nothing else from this article, take this:

Write down what you won’t do.

It feels awkward. It feels negative. But it is the single most effective thing you can add to any freelance agreement.

“SEO optimization beyond basic meta tags — not included.”

“Photography and video production — not included.”

“Ongoing maintenance after 30-day post-launch period — not included.”

“Any pages beyond the 5 listed above — not included.”

Every item on that list is a conversation you won’t have to
have at 11pm on a Tuesday when you’re already three weeks into
a two-week project.

Start Simple

You don’t need a lawyer. You don’t need a complex legal document.

Start with a simple one-page document that answers:

What am I building?
What am I NOT building?
When will it be done?
How much does it cost?
When do I get paid?

Get that signed — even just an email reply saying “I agree to
these terms” — before you start any work.

That one habit will save you more money and stress than almost
anything else you do as a freelancer.

Built stecya.com after this experience — free AI SOW generator for freelancers. Takes 30 seconds. No credit card required.

Split your AWS AppSync schema across multiple files

Moya Richards — Sat, 18 Apr 2026 04:46:24 +0000

If you’re working with AWS AppSync or any modular GraphQL API, you’ve probably want to split your schema across multiple files. This is great for developer sanity—but AppSync prefers a single .graphql file.

Let’s automate that.

This post walks through a simple Node.js script that uses the @graphql-tools ecosystem to:

✅ Load and merge your GraphQL schemas
✅ Resolve conflicts
✅ Write the final result to a single .graphql file
✅ load schema into your AppSync deployment flow

🛠 Setup

Install the necessary dependencies:

npm install @graphql-tools/load-files @graphql-tools/merge graphql

📦 Your Project Structure

Assume your project is organized like this:

project-root/
├── appsync/
│   ├── mutations/
│   │   └── addCustomer.graphql
│   ├── queries/
│   │   └── getCustomer.graphql
│   └── schema_chatbot_quicksight_merged.graphql (output)
├── mergeSchemas.js

🧩 The Merge Script

Here’s the full script to merge your GraphQL schema files:

import { loadFilesSync } from "@graphql-tools/load-files";
import { mergeTypeDefs } from "@graphql-tools/merge";
import { print } from "graphql";
import fs from "fs";
import path from "path";
import { fileURLToPath } from "url";

try {
    const __filename = fileURLToPath(import.meta.url);
    const __dirname = path.dirname(__filename);
    const mergedFileName = "schema_chatbot_quicksight_merged.graphql";
    const outputPath = path.join(__dirname, "./appsync", mergedFileName);

    const typesArray = loadFilesSync(path.join(__dirname, "./appsync/**/*.graphql"), {
        extensions: [".graphql"],
        ignore: [mergedFileName],
    });

    if (!typesArray || typesArray.length === 0) {
        throw new Error("No GraphQL schema files found");
    }

    console.log(
        "Loaded files:",
        typesArray.map((t) => t?.loc?.source?.name || typeof t),
    );

    const mergedTypeDefs = mergeTypeDefs(typesArray, {
        all: true,
        throwOnConflict: true,
    });

    const sdl = print(mergedTypeDefs);

    const outputDir = path.dirname(outputPath);
    if (!fs.existsSync(outputDir)) {
        fs.mkdirSync(outputDir, { recursive: true });
    }

    fs.writeFileSync(outputPath, sdl);
    console.log(`✅ Merged schema written to appsync/${mergedFileName}`);
} catch (error) {
    console.error("❌ Error merging GraphQL schemas:", error.message);
    process.exit(1);
}

🚀 Using It in AWS CDK

Once your merged schema is generated, you can use it directly in your CDK stack with aws-cdk-lib/aws-appsync.

Here’s an example:

import * as cdk from "aws-cdk-lib";
import { Construct } from "constructs";
import * as appsync from "aws-cdk-lib/aws-appsync";
import * as path from "path";

export class AppsyncStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const api = new appsync.GraphqlApi(this, "graphql-api", {
      name: "ChatbotQuickSightApi",
      schema: appsync.SchemaFile.fromAsset(
        path.join(__dirname, "../appsync/schema_chatbot_quicksight_merged.graphql")
      ),
      authorizationConfig: {
        defaultAuthorization: {
          authorizationType: appsync.AuthorizationType.API_KEY,
        },
      },
      xrayEnabled: true,
    });

    new cdk.CfnOutput(this, "GraphQLAPIURL", {
      value: api.graphqlUrl,
    });
  }
}

🧠 Tip

You can run your mergeSchemas.js script as part of your CDK build pipeline. For example:

"scripts": {
  "prepare-schema": "node mergeSchemas.js",
  "build": "npm run prepare-schema && cdk synth"
}

🧼 Why This Matters

Keep your schema modular for readability and reuse
Deliver a single file AppSync expects without error-prone copy/paste
Enable CI/CD integration with schema validation and bundling in one step

Supercharge AWS Diagrams in VSCode with Mermaid and Custom Icons

Moya Richards — Sat, 18 Apr 2026 04:45:00 +0000

Want to turn your architecture docs into visual gold? With the new Mermaid.js architecture diagram syntax and custom icon packs, you can create AWS diagrams—all from within VSCode using Markdown.

This guide walks you through how to:

✅ Use Mermaid’s new architecture syntax
✅ Set up custom AWS and icon libraries
✅ Preview it all in VSCode using the Markdown Preview Enhanced extension

Let’s dive in. 👇

🔧 Icon Packs You'll Use

Here are the icon libraries we’ll pull in:

These icons can be referenced in your Mermaid diagrams by name (e.g. logos:aws-lambda, aws:aurora, fa: ,).

✅ Step 1: Install Markdown Preview Enhanced

First, install the Markdown Preview Enhanced extension in VSCode.

It enables rich previews for .md files—supporting Mermaid, LaTeX, charts, diagrams, and more.

⚙️ Step 2: Inject Icon Packs into Mermaid

We’ll now customize the Markdown preview to load external icon packs into Mermaid.

How to set it up:

In VSCode, press Ctrl + P, then type:

   > Markdown Preview Enhanced: Customize Preview Html Head (WORKSPACE)

Select the command. It will create a file:

   .crossnote/head.html

Paste the following code into that file:

<!-- Load custom icon packs for Mermaid architecture diagrams -->
<script type="text/javascript">
  const configureMermaidIconPacks = () => {
    window["mermaid"].registerIconPacks([
      {
        name: "logos",
        loader: () =>
          fetch("https://unpkg.com/@iconify-json/logos/icons.json").then(res =>
            res.json()
          ),
      },
      {
        name: "lucide",
        loader: () =>
          fetch("https://unpkg.com/@iconify-json/lucide/icons.json").then(res =>
            res.json()
          ),
      },
      {
        name: "fa",
        loader: () =>
          fetch("https://unpkg.com/@iconify-json/fa/icons.json").then(res =>
            res.json()
          ),
      },
      {
        name: "aws",
        loader: () =>
          fetch(
            "https://raw.githubusercontent.com/awslabs/aws-icons-for-plantuml/aa30729ab2e125f13526020fa98ed5eb0ed86cc1/dist/aws-icons-mermaid.json"
          ).then(res => res.json()),
      },
    ]);
  };

  if (document.readyState !== "loading") {
    configureMermaidIconPacks();
  } else {
    document.addEventListener("DOMContentLoaded", () => {
      configureMermaidIconPacks();
    });
  }
</script>

This ensures Mermaid can load and render your custom icons directly in preview.

🖼️ Step 3: Create a Diagram with AWS Icons

Now create a .md file (e.g. README.md) and embed a Mermaid diagram using the new architecture syntax and icons.

Here’s a full example using AWS services:

Click to expand the Mermaid diagram example

---
config:
  theme: base
  themeVariables:
    darkMode: false
    archEdgeColor: "#232F3E"
    archEdgeArrowColor: "#232F3E"
    archGroupBorderColor: "#ff862a"
---
architecture-beta


service user_service(lucide:user)[Users via Web Browser]

group cdk_infra(cloud)[AWS CDK Infrastructure]

service waf(logos:aws-waf)[AWS WAF] in cdk_infra
service cloudfront(logos:aws-cloudfront)[Amazon CloudFront] in cdk_infra
service cognito(logos:aws-cognito)[Amazon Cognito] in cdk_infra
service s3_front(logos:aws-s3)[Amazon S3 Frontend Hosting] in cdk_infra
service apigw(logos:aws-api-gateway)[Amazon API Gateway] in cdk_infra
service appsync(logos:aws-appsync)[AWS AppSync] in cdk_infra
service cdk_deploy(aws:cloudformation)[AWS CDK Deployment] in cdk_infra

group vpc_private_subnet(cloud)[VPC Private Subnet] in cdk_infra

service lambda(logos:aws-lambda)[AWS Lambda] in vpc_private_subnet
service dynamodb(logos:aws-dynamodb)[Amazon DynamoDB] in vpc_private_subnet
service aurora(logos:aws-aurora)[Amazon Aurora PostgreSQL] in vpc_private_subnet
service sagemaker(aws:sagemaker)[Amazon SageMaker] in vpc_private_subnet
service bedrock(aws:bedrock)[Amazon Bedrock] in vpc_private_subnet
service step_functions(logos:aws-step-functions)[AWS Step Functions] in vpc_private_subnet
service s3_ingest(logos:aws-s3)[Amazon S3 Ingestion] in vpc_private_subnet
service lambda_ingest(logos:aws-lambda)[AWS Lambda Ingestion] in vpc_private_subnet


user_service:R --&gt; L:waf
waf:R --&gt; L:cloudfront
cloudfront:R --&gt; L:cognito
cognito:R --&gt; L:s3_front
s3_front:R --&gt; L:apigw
s3_front:B --&gt; L:appsync
apigw:R --&gt; L:lambda
appsync:R --&gt; L:lambda
lambda:R --&gt; L:dynamodb
lambda:B --&gt; T:aurora
lambda:T --&gt; B:bedrock
sagemaker:R --&gt; B:s3_ingest
step_functions:R --&gt; L:s3_ingest
s3_ingest:R --&gt; L:lambda_ingest
lambda_ingest:R --&gt; L:dynamodb
lambda_ingest:R --&gt; L:aurora
cdk_deploy:R --&gt; L:step_functions

view in the Mermaid Live Editor

🎉 That’s It!

You now have a fully working setup to design AWS diagrams using Mermaid in VSCode—with custom icons and rich architecture syntax. It’s perfect for:

Internal docs and wikis
Cloud architecture planning
README files that actually explain things

🛠 Bonus Tips

If icons don’t appear, double-check you’re in the Markdown Preview Enhanced window (not the default preview).

OpenClaw + GLM 5.1 = FREE AI AGENTS

ANIRUDDHA ADAK — Sat, 18 Apr 2026 04:44:46 +0000

This is a submission for the OpenClaw Writing Challenge

In this guide, I'll walk you through installing three tools step by step that together give you a free personal AI assistant running right on your computer.

No subscriptions, no monthly fees = completely free.

Here's what we'll install:

Ollama:

A program that lets you run AI models directly on your computer. Think of it as an "engine" that powers artificial intelligence locally. Works on macOS, Windows, and Linux.

GLM-5.1:

An AI model from Chinese company Z.AI (formerly Zhipu AI). Released on April 7, 2026, it's one of the best open-source models in the world. On the SWE-Bench Pro benchmark (a coding test), it scored 58.4 points, more than GPT-5.4 and Claude Opus 4.6. And it's completely free under the MIT license.

OpenClaw:

An AI agent that transforms a regular language model into a full-featured assistant. It can send messages via WhatsApp, Telegram, Slack, Discord, search the web, work with files, write code, and automate tasks. OpenClaw launches through Ollama with a single command.

System Requirements

Before installing, make sure your computer meets these requirements:

Minimum (for cloud models via Ollama Cloud):

Any modern computer
8 GB RAM
5 GB free disk space
Internet connection
Node.js version 22 or newer

Recommended (for local models):

16 GB RAM (for medium-sized models)
GPU with 8+ GB VRAM (NVIDIA recommended)
20+ GB free disk space
Running the full GLM-5.1 locally requires server hardware (the model has 744 billion parameters), but the cloud version via Ollama is free

Important:

If you don't have a powerful GPU, don't worry! GLM-5.1 is available as a cloud model through Ollama (glm-5.1:cloud), and it runs fast without any hardware requirements on your end.

1. Install Ollama

https://ollama.com/

Ollama is the foundation of the entire system. We start here.

Install Ollama by following the link to the official website. Paste the command into the terminal or download the app.

Now Ollama is installed.

2. Choosing GLM 5.1 model

Just type ollama and the program will launch, then select the option “Chat with a model”.

Next, select the desired model, in my case GLM 5.1.

You'll be able to chat with it right in the terminal, ask questions, request code, analyze texts, and more.

Important:

To use cloud models, you need to sign in to an Ollama account. If you don't have one yet, Ollama will prompt you to create one when you first launch a cloud model. It's free.

Now we are connected via the cloud version of GLM 5.1.

3. OpenClaw

https://ollama.com/

Next, going down a little further on the same site, we will install OpenClaw using the command (if it is not already installed):

Ollama will check if OpenClaw is installed on your computer
If not, it will download and install it via npm (Node.js must be installed)
A security notice will appear (OpenClaw is getting access to tools on your computer) – accept it
A model selection screen will open, choose the one you need (for example, glm-5.1:cloud)
OpenClaw will launch in the terminal, and you can start chatting

Launch with configuration before starting:

If you want to configure OpenClaw first (choose a model, connect messengers, etc.):

ollama launch openclaw --config

4. OpenClaw Control Panel (Control UI)

After launching OpenClaw, you can open the web control panel in your browser. Go to:

http://localhost:3000

In the Control UI you'll find:

Chat – chat with the AI assistant right in the browser
Overview – general information about the agent's status
Channels – connect messengers (WhatsApp, Telegram, Slack, Discord, iMessage)
Instances – manage running instances
Sessions – session and conversation history
Usage – usage statistics
Cron Jobs – automated scheduled tasks

At the top of the panel, you can switch between channels and models.

5. Connecting automatic web search

https://docs.ollama.com/integrations/openclaw#web-search-and-fetch

Next, we follow the documentation and enable automatic web search.

OpenClaw can search for information on the internet. If you're using a cloud model through Ollama, web search is enabled automatically.

For local models, you need to install the plugin:

openclaw plugins install @ollama/openclaw-web-search

6. Connecting the messaging platform

https://docs.ollama.com/integrations/openclaw#connect-messaging-apps

Now you can connect messengers that will make it easier to communicate with your agent.

One of OpenClaw's key features is the ability to chat with the AI agent through familiar messengers. You send a message on Telegram and get a response from AI.

Channel setup is done through the Control Panel (Control UI) or via the command:

ollama launch openclaw --config

Select the “Channels” section and follow the instructions to connect the messenger you need.

Link WhatsApp, Telegram, Slack, Discord, or iMessage with this command:

openclaw configure --section channels

For example, to connect a Telegram account, you will need to:

Go to the Telegram bot “BotFather”
Start it
Create a new bot by giving it a name and a username
Once the bot is successfully created, grab its token

Next we add our bot token in the terminal, and we're all set.

7. Using with Claude Code and Codex (Bonus)

Ollama also lets you launch other AI development tools. As shown on the GLM-5.1 page on Ollama, there are ready-made commands:

Claude Code with GLM-5.1:

ollama launch claude --model glm-5.1:cloud

Codex with GLM-5.1:

ollama launch codex --model glm-5.1:cloud

OpenCode with GLM-5.1:

ollama launch opencode --model glm-5.1:cloud

This lets you harness the power of GLM-5.1 through different programming interfaces.

About the GLM-5.1 Model: Why It Matters

GLM-5.1 is a next-generation model from Z.AI (formerly Zhipu AI, a Tsinghua University spinoff). Key facts:

Architecture: 744 billion parameters (Mixture-of-Experts), 40 billion active parameters per token
Context window: 200,000 tokens
License: MIT (completely free, use however you want)
Release date: April 7, 2026

GLM-5.1's key feature is its ability to work autonomously for up to 8 hours, revising its strategy and finding new approaches to problem-solving.

While other models “run out of steam” after their initial attempts, GLM-5.1 continues improving results through hundreds of iterations.

Three commands. Zero subscriptions. Your own AI agent that works for you, not someone else's server. The future is here and it's free.

🔖 Bookmark this – you'll need it again.

🔔 Follow my profile, so you catch guides like this first.

Anthropic Just Gave Claude a Design Studio. Here's What Claude Design Actually Does.

Om Shree — Sat, 18 Apr 2026 04:44:41 +0000

Figma has been the unchallenged center of digital design for years. Yesterday, Anthropic quietly placed a bet that AI can change that.

On April 17, Anthropic launched Claude Design - a new product under its Anthropic Labs umbrella that lets you collaborate with Claude to build visual work: prototypes, slides, wireframes, landing pages, one-pagers, and more. It's powered by Claude Opus 4.7, their latest vision model, and it's rolling out in research preview for Pro, Max, Team, and Enterprise subscribers right now.

This isn't Claude generating pretty mockups you paste into Figma. This is a full design loop - ideation, iteration, export, and handoff - without ever leaving the chat.

The Problem It's Solving

Anthropic frames the core issue well: even experienced designers ration exploration. There's never enough time to prototype ten directions, so you pick two or three and commit. And for founders, PMs, and marketers who have a strong vision but no design background, turning ideas into shareable visuals has always required either hiring someone or learning tools that take months to master.

Claude Design is trying to solve both problems at once. Give designers room to explore widely. Give everyone else a way to produce visual work that doesn't look like a Canva template from 2019.

How the Workflow Actually Works

The flow is more structured than you'd expect from a chat-based tool.

Your brand gets built in first. During onboarding, Claude reads your codebase and design files to build a design system - your colors, typography, components. Every project after that inherits it automatically. No more pasting hex codes into every prompt.

You can start from anything. A text prompt, uploaded images, a DOCX, PPTX, or XLSX file, your codebase, or a live website via the web capture tool. If you want the prototype to look like your actual product, you point it at your site and Claude pulls the elements directly.

Iteration happens inline. You can comment on specific elements, edit text directly, or use custom adjustment knobs - built by Claude - to tweak spacing, color, and layout live. Then ask Claude to apply changes across the entire design at once.

Collaboration is organization-scoped. Keep designs private, share a view-only link inside your org, or grant edit access so teammates can jump into the same conversation with Claude together.

Export goes everywhere. Standalone HTML, PDF, PPTX, a shareable internal URL, or directly to Canva. The Canva integration is a first-class feature - designs land as fully editable Canva files, ready to refine and publish.

Handoff goes to Claude Code. When a design is ready to build, Claude bundles everything into a handoff package you pass to Claude Code with a single instruction. Design to implementation in one pipeline.

What Teams Are Actually Using It For

Anthropic lists six core use cases, and they're more specific than the usual "boost your productivity" marketing copy:

Realistic prototypes - Designers turn static mockups into interactive, shareable prototypes without touching code or going through PR review.
Product wireframes - PMs sketch feature flows and hand off directly to Claude Code for implementation, or to designers for refinement.
Design explorations - Quick generation of a wide range of visual directions to explore before committing.
Pitch decks and presentations - From rough outline to on-brand deck in minutes, exported as PPTX or sent to Canva.
Marketing collateral - Landing pages, social media assets, campaign visuals, ready for designer polish.
Frontier design - Code-powered prototypes with voice, video, shaders, 3D, and built-in AI.

That last one is the most interesting. "Frontier design" positions this beyond Figma's territory entirely - into interactive, AI-native artifacts that traditional design tools can't produce at all.

What Early Users Are Saying

Three companies shared early reactions, and the numbers are specific enough to be credible.

Brilliant, the interactive learning platform, noted that their most complex pages - which previously took 20+ prompts to recreate in other tools - required only 2 prompts in Claude Design. Their Senior Product Designer called the prototype-to-production handoff with Claude Code "seamless."

Datadog's product team reported going from rough idea to working prototype before anyone leaves the room. Work that previously took a week of back-and-forth between briefs, mockups, and review rounds now happens in a single conversation.

Canva co-founder and CEO Melanie Perkins framed the integration as a natural extension of their mission - bringing Canva to wherever ideas begin. When a design exits Claude Design into Canva, it becomes fully editable and collaborative immediately.

Why This Is a Bigger Deal Than It Looks

Most AI design tools have been wrappers - you describe something, get an image, manually replicate it in your actual design tool. Claude Design is different in structure. The brand system, the inline editing, the Claude Code handoff, the Canva export - these aren't convenience features. They're the infrastructure of a complete design workflow.

What Anthropic is building here is a design agent, not a design assistant. One that holds context about your brand, your product, your team's work, and the full history of a project. That's the same pattern we've seen with Claude Code in engineering - an AI that doesn't just answer questions but participates in the actual production pipeline.

The implications for teams without dedicated design resources are significant. A founder with a clear vision and access to Claude Pro can now go from napkin sketch to investor-ready prototype without a single design hire. A PM can produce a feature wireframe precise enough to hand off to engineering directly. A marketer can generate a campaign landing page in a conversation.

Availability and Access

Claude Design is available now in research preview for Pro, Max, Team, and Enterprise subscribers at claude.ai/design. Access is included in your existing plan and uses your subscription limits, with the option to enable extra usage if you go beyond them.

For Enterprise orgs, it's off by default - admins can enable it via Organization settings.

Anthropic says integrations with more tools are coming in the next few weeks.

Design just became part of the agentic stack. The question now is how fast the design community actually adopts it - and what Figma does next.

Follow for more coverage on MCP, agentic AI, and AI infrastructure.

Weekend Project: Build a ₹0 Amazon India Price Tracker in 50 Lines of Python

Archit Mittal — Sat, 18 Apr 2026 04:43:35 +0000

Saturday afternoon. You've been eyeing that ₹45,000 laptop on Amazon India for three weeks. Does it dip during the Great Indian Sale? Does it spike on weekends? Nobody knows — because nobody is watching.

Today we'll fix that with ~50 lines of Python. No paid APIs, no ₹499/month SaaS, no Chrome extensions that sell your data. Just a weekend project you can finish before dinner.

What we're building

A tiny script that:

Visits an Amazon India product URL.
Scrapes the current price.
Logs it to a CSV with a timestamp.
Pings you on Telegram if the price drops below a target.

Total build time: ~45 minutes. Total cost: ₹0.

Step 1 — Install the basics

You need Python 3.9+ and two libraries:

pip install requests beautifulsoup4

That's it. No Selenium, no headless Chrome, no scraping service.

Step 2 — The scraper

Amazon blocks bare requests calls, so we send a real browser's User-Agent and accept-language header. This works 90% of the time for public product pages; if you hit a CAPTCHA, just wait an hour and try again.

import requests
from bs4 import BeautifulSoup

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 13_5) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/124.0.0.0 Safari/537.36"
    ),
    "Accept-Language": "en-IN,en;q=0.9",
}

def get_price(url: str) -> tuple[str, int]:
    r = requests.get(url, headers=HEADERS, timeout=20)
    r.raise_for_status()
    soup = BeautifulSoup(r.text, "html.parser")

    title = soup.select_one("#productTitle").get_text(strip=True)
    price_el = soup.select_one(".a-price .a-offscreen")
    if not price_el:
        raise RuntimeError("Price element not found — page layout changed.")

    # "₹45,999.00" -> 45999
    raw = price_el.get_text(strip=True).replace("₹", "").replace(",", "")
    rupees = int(float(raw))
    return title, rupees

Two things worth noting:

The CSS selectors (#productTitle, .a-price .a-offscreen) are stable on Amazon India as of 2026, but Amazon rotates layouts. If your script breaks, right-click the price → Inspect → copy a fresh selector.
Always check raise_for_status(). A 503 usually means you hit Amazon's rate limit — back off, don't hammer it.

Step 3 — The logger

CSV is fine. You don't need a database for a personal price tracker.

import csv
from datetime import datetime
from pathlib import Path

LOG = Path("prices.csv")

def log_price(title: str, rupees: int) -> None:
    new = not LOG.exists()
    with LOG.open("a", newline="", encoding="utf-8") as f:
        w = csv.writer(f)
        if new:
            w.writerow(["timestamp", "title", "rupees"])
        w.writerow([
            datetime.now().isoformat(timespec="seconds"),
            title,
            rupees,
        ])

After a week of data you'll have a CSV you can open in Excel or pandas. Plot it. Watch the weekend dips.

Step 4 — The Telegram alert

Create a Telegram bot via @botfather, note the token, and message your bot once so it knows your chat ID (fetch it from https://api.telegram.org/bot<TOKEN>/getUpdates).

import os

BOT_TOKEN = os.environ["TG_BOT_TOKEN"]
CHAT_ID = os.environ["TG_CHAT_ID"]

def ping(msg: str) -> None:
    requests.post(
        f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage",
        data={"chat_id": CHAT_ID, "text": msg},
        timeout=10,
    )

Environment variables, not hardcoded tokens. Always.

Step 5 — Tie it together

PRODUCTS = [
    ("https://www.amazon.in/dp/B0CHX1W1XY", 45000),  # (url, target_rupees)
    ("https://www.amazon.in/dp/B0BDHWDR12", 12000),
]

def main():
    for url, target in PRODUCTS:
        try:
            title, price = get_price(url)
            log_price(title, price)
            if price <= target:
                ping(f"💸 {title[:60]} is ₹{price:,} (target ₹{target:,})\n{url}")
            print(f"OK ₹{price:,} — {title[:60]}")
        except Exception as e:
            print(f"FAIL {url[:60]} — {e}")

if __name__ == "__main__":
    main()

That's the full 50 lines. Save it as price_tracker.py.

Step 6 — Schedule it

On macOS or Linux, cron runs it every 6 hours:

0 */6 * * * cd /home/you/tracker && /usr/bin/python3 price_tracker.py >> tracker.log 2>&1

On Windows, Task Scheduler does the same. On a Raspberry Pi? Even better — your tracker runs 24/7 on ₹200/year of electricity.

What you'll notice after 2 weeks

Running this on 5–10 products for two weeks taught me three things I didn't know:

Amazon India prices move daily, not seasonally. Same laptop: ₹45,999 on Tuesday, ₹43,499 on Saturday, ₹46,499 on Monday.
"Deals of the Day" aren't usually the lowest price that month. The real dip often happens the week after a sale ends.
Pin codes matter. A product shown at ₹1,299 in Mumbai can be ₹1,399 in a Tier-2 pin code — the script above uses whatever pin code Amazon defaults to. Add a ?pincode=110001 variant if you want consistency.

Ways to extend it this weekend

If you finish early, three upgrades worth ~30 min each:

Flipkart support — different selectors, same pattern. You now track both in one CSV.
7-day rolling min/max — load the CSV with pandas, alert only when price hits a new 7-day low.
Chart generator — a weekly email with a matplotlib PNG of every product you're tracking.

A small warning

Scraping at human-level frequency (every few hours, a handful of products) is fine. Scraping 10,000 URLs every 60 seconds will get your IP blocked and is against Amazon's ToS. Be a good citizen. If you need scale, pay for a proper scraping API — but for personal use, this script is plenty.

That's the whole weekend project. Clone, customize, commit. By Sunday evening you'll have a working tracker and a week of data starting to pile up.

Ping me on Dev.to if you ship it — I read every reply.

I'm Archit Mittal — I automate chaos for businesses. Follow me for daily automation content.

How I Prepared for Outreachy as a Beginner

Brian Oiko — Sat, 18 Apr 2026 04:35:17 +0000

When I first heard about Outreachy, I was excited.

Then I looked at the requirements… and reality hit.

I wasn’t “ready.”

I had done tutorials. Built small projects. But contributing to real open-source projects? That felt like a completely different level.

Still, I decided to try.

This is how I prepared — and what actually made a difference.

🚧 Step 1: I Accepted That I Didn’t Know Enough

At the beginning, I kept thinking:

«“I need to learn more before I start contributing.”»

That mindset slowed me down.

What changed everything was realizing:
You don’t need to be fully ready — you just need to start.

Instead of waiting, I began exploring real project repositories.

🔍 Step 2: Learning How to Read Code (Not Just Write It)

One of the biggest challenges was understanding other people’s code.

It wasn’t like tutorials:

No step-by-step guidance
No simplified examples
No clear starting point

At first, it felt overwhelming.

So I changed my approach:

I focused on small parts of the codebase
I traced how data flows through the system
I took notes on what I didn’t understand

Slowly, things started making sense.

🛠️ Step 3: Starting Small (Very Small)

I didn’t try to solve complex issues immediately.

Instead, I looked for:

Documentation fixes
Small bugs
Beginner-friendly issues

These helped me:

Understand the workflow
Build confidence
Learn how contributions actually work

💬 Step 4: Asking Better Questions

At first, I was afraid to ask questions.

But I realized:
Good questions show effort — not weakness.

Instead of saying:

«“I don’t understand this”»

I started asking:

«“I tried X and Y, but I’m confused about Z. Am I approaching this correctly?”»

That small change made people more willing to help.

🔁 Step 5: Embracing Feedback

My early contributions weren’t perfect.

I got feedback like:

“This can be improved”
“Consider another approach”
“Follow project conventions”

At first, it felt discouraging.

But over time, I understood:
Feedback is part of the process — not a sign of failure.

⏳ Step 6: Consistency Over Intensity

I didn’t spend 10 hours a day.

Instead, I showed up consistently:

Reading code
Trying small fixes
Learning from mistakes

Progress was slow… but it was real.

💡 What Actually Worked

Looking back, these made the biggest difference:

Starting before I felt ready
Focusing on understanding, not speed
Taking small, consistent steps
Asking thoughtful questions
Learning from feedback instead of avoiding it

🔥 Final Thoughts

Outreachy isn’t just about getting selected.

It’s about becoming a developer who can:

Work with real codebases
Collaborate with others
Learn independently

And that journey starts long before selection.

If you’re preparing right now, just remember:

You don’t need to be perfect.

You just need to keep showing up.

If you're on a similar journey, I’d love to hear your experience.

Let’s connect:
GitHub: https://github.com/Brace1000
LinkedIn: https://linkedin.com/in/brianoiko

Constructor in Java

PRIYA K — Sat, 18 Apr 2026 04:33:27 +0000

A special method used to initialise objects.
Constructor is a block of code similar to method
Constructor is called when an object of a class is created

All Classes have constructors by 'default'
Java (JDK) creates a Class Constructor ,you need not to create a Class constructor
Accept parameters to initialise Object properties
It is used to set default or user-defined values for the object's attributes
Initialise objects at the time of object creation.

Constructor Syntax

class ClassName {
    // Constructor
    ClassName() {
        // Initialization code
    }

    // Parameterized Constructor
    ClassName(dataType parameter1, dataType parameter2) {
        // Initialization code using parameters
    }

    // Copy Constructor
    ClassName(ClassName obj) {
        // Initialization code to copy attributes
    }
}

Example

class Bike{
    Bike(){
        System.out.println("Bike is created");
    }
    public static void main(String[]args){
        Bike b = new Bike();

    }

}

Output

Rules For Creating Constructor
1.Name Rule
Constructor name must match the Class name
2.Return Type Rule
It cannot have a return type (like void) or explicit return type
if you add a return type,it will become a method not a return type
3.Execution Rule
A constructor is called as per the object creation(New)
4.Default Constructor Rule
No constructor is defined, Java provides a default no-arg constructor.
you can define any constructor, the default is not automatically provided.
5.Access Modifiers Rule
A constructor have modifiers like Private,Public,Protected or default
Private Constructore have used in singleton Design Pattern
to be discussed...
6.Restrictions Rule
A constructor cannot be

static(Belong to Class,not Objects)
final(Not Inherited)
abstract(must have a body)
and synchronised to be discussed...

7.Inheritance Rule
Constructor not inherited by SubClass
Call a Parent Constructor using Super()

8.this() and super() Rule
A constructor can call another constructor in the same class using this().
A constructor can call a parent’s constructor using super().
In Java ≤ 24 → must be the first statement.
In Java 25 → can appear anywhere in the constructor.

Types Of Constructor

Default Constructor
Parameterised Constructor
No-argument Constructor

Default Constructor (Implicit)
A constructor doesnot have any parameter
Doesnot defined any constructor
They Initialise Object with Default Values
A constructor that is automatically provided by Java if no constructor is written in the class.
It initializes object with default values (0, null, false).

Example
It is called when the object of the class is created

class Bike {
    int id;
    String name;

    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b = new Bike();   // calls default constructor
        b.display();
    }
}

Output

Purpose Of Default Constructor
Provide Default values to the object like 0,null.depending on their data type.

No-Argument Constructor(User-defined)
user-defined empty constructor
A constructor that is manually written by the programmer with no parameters.
It is used to initialize objects with custom default values.

class Bike {
    int id;
    String name;

    // No-argument constructor
    Bike() {
        id = 101;
        name = "Duke";
    }

    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b = new Bike();
        b.display();
    }
}

Output

Parameterised Constructor(Explicit)
A constructor have a any number of parameter
Used to provide different value for objects
Accepts arguments to initialize an object with specific values.
It allows passing values while creating the object.

class Bike {
    int id;
    String name;

    // Constructor only initializes values
    Bike(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // Method to display bike details
    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b = new Bike(111, "Duke");
        Bike p = new Bike(122, "Splender");

        b.display();
        p.display();
    }
}

Output

Constructor OverLoading
Allows to create multiple constructors in the same class with different parameter and different data type
It can be overloaded like Java Methods
You can define all type of Constructors like no-argument and parameterised constructor.

Example

class Bike {
    int id;
    String name;

    // 1. Constructor with no parameters
    Bike() {
        id = 0;
        name = "Null";
    }

    // 2. Constructor with one parameter
    Bike(int id) {
        this.id = id;
        this.name = "Default Bike";
    }

    // 3. Constructor with two parameters
    Bike(int id, String name) {
        this.id = id;
        this.name = name;
    }

    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b1 = new Bike();              // calls 1st constructor
        Bike b2 = new Bike(111);           // calls 2nd constructor
        Bike b3 = new Bike(122, "Duke");   // calls 3rd constructor

        b1.display();
        b2.display();
        b3.display();
    }
}

Output

What is this() in java 25 Upadte
It is used to call another Constructor with the same class(Constructor Chaining)
The restriction this() and super() used as first statement in constructor is removed.
Place them anywhere inside a constructor
this() and super()=>they enable clean and flexible initialization.

Copy Constructor
A constructor that creates a new object by copying values from an existing object of the same class.
It is used to duplicate objects.

class Bike {
    int id;
    String name;

    Bike(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // Copy constructor
    Bike(Bike b) {
        this.id = b.id;
        this.name = b.name;
    }

    void display() {
        System.out.println(id + " " + name);
    }

    public static void main(String[] args) {
        Bike b1 = new Bike(111, "Duke");

        Bike b2 = new Bike(b1);  // copy constructor

        b1.display();
        b2.display();
    }
}

Output

Do You Know?
1.this Keyword (Avoid confusion)
Used when class variable and parameter have same name
this refers to current object
this() calls another constructor

Example:

class Bike {
    int id;
    String name;

    Bike(int id, String name) {
        this.id = id;      // class variable = parameter
        this.name = name;
    }
}

Explanation
this.id → object’s variable
id → constructor parameter

Without this, Java gets confused

2.Constructor Chaining (this())

One constructor calling another constructor
Simple idea:
“Reuse constructor instead of writing same code again”

Example:

class Bike {
    int id;
    String name;

    Bike() {
        this(0, "Unknown");  // calls another constructor
    }

    Bike(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

Bike() → calls Bike(int, String)
Saves duplicate code

3.Immutable Object (Fixed data)

Once object is created, you cannot change its values
Means
“Lock the object after creation "

Example:

class Student {
    private final String name;
    private final int age;

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
}

final → cannot change value
No setter methods → data is fixed

4. Exception Handling in Constructor
Handle errors while creating object
stop invalid object creation

Means
“If object is wrong, stop it immediately”

Example:

class Student {
    int age;
    Student(int age) {
        if (age < 0) {
            throw new Illegal ArgumentException("Age cannot be negative");
        }
        this.age = age;
    }
}

If invalid data comes → constructor blocks it
Object is created only if data is correct

RecallPal

Sayantan Bhattacharjee — Sat, 18 Apr 2026 04:26:46 +0000

I Built a Real-Time Face Recognition Memory Aid for Dementia Patients — Here's How the Memory Layer Actually Works

My grandmother stopped recognizing my father about two years before she passed. She knew someone was in the room. She could tell he cared about her. But the name, the relationship, the decades of shared history — gone. That experience sat with me for a long time.

So when I started thinking about what kind of system I actually wanted to build, the answer was straightforward: something that bridges that gap in real time. Not a research prototype. A working system that a caregiver could set up in an afternoon and that would tell a dementia patient — quietly, clearly — who just walked into the room and why they matter.

The result is Dementia Assist: a real-time face recognition system backed by a persistent memory layer that stores not just who someone is, but what you know about them — their relationship to the patient, their interests, how long it's been since their last visit, and a dynamically generated conversation starter to help break the ice.

How the System Hangs Together

The architecture is deliberately simple. A Next.js frontend captures webcam frames once per second and POSTs them as base64 JPEGs to a Flask backend. The backend runs them through a FaceNet embedding model via DeepFace, compares the result against a pickled embedding database, and — if there's a match — queries a memory store for everything we know about that person. The response comes back with a name, a confidence score, relationship context, and a suggestion like "Ask Sarah about her painting class."

The stack:

Face recognition: DeepFace + FaceNet (128-dimensional embeddings, Euclidean distance matching)
Memory: Hindsight Cloud with a local JSON fallback
Backend: Python 3.9, Flask, flask-cors
Frontend: Next.js 14, TypeScript, Tailwind CSS
Voice: Web Speech API for audio announcements when a face is recognized

The whole thing starts with a single script — ./run.sh on Linux/macOS, run.bat on Windows — which installs dependencies, starts both servers, and opens the browser. I wanted caregivers to be able to run this without touching a terminal again after setup.

The Core Technical Problem: Recognition Alone Is Not Enough

Early on I made a mistake that I think a lot of people make when building systems like this: I treated face recognition as the hard problem and memory as an afterthought.

Recognition is actually fairly tractable. DeepFace with FaceNet gives you solid 128-d embeddings. You store them in a pickle file, compute Euclidean distances at inference time, set a threshold, done. What I underestimated was what you do with the name once you have it.

A dementia patient doesn't just need to know a name. They need context. Who is this person? When did I last see them? What do we talk about? If you flash "Sarah" on a screen with no surrounding information, you've built a party trick, not an aid.

That's where I knew I needed agent memory — not a database query, but something that could store rich, evolving context about each person and retrieve it intelligently at recognition time.

I looked at a few options and landed on Hindsight for the memory layer. What sold me was the combination of a clean Python client, an isolated bank-per-application model, and the fact that it degrades gracefully — if you don't have an API key, it falls back to a local JSON store with the exact same interface. That meant I could build and test everything offline without mocking anything out.

How Memory Storage and Retrieval Actually Works

Each person in the system has two representations:

A face embedding (or several) stored in face_db.pkl
A memory record stored in Hindsight (or memory_store.json locally)

The memory record looks like this:

PREDEFINED_PEOPLE: dict[str, dict] = {
    "Sayantan": {
        "text": (
            "Sayantan is a 21-year-old computer science student interested in AI and "
            "coding. He enjoys chess and music and often helps with technical work."
        ),
        "age":      21,
        "relation": "Friend",
        "likes":    ["AI", "Coding", "Chess", "Music"],
        "notes":    "Helpful and calm personality",
    },
    ...
}

On startup, seed_initial_data() checks whether each predefined person already exists in Hindsight and skips them if so — idempotent seeding, no duplicates. New people enrolled live go through the same store_person() path:

def store_person(self, name, relation, notes, age=None, likes=None) -> bool:
    key = name.lower()
    now = _now_iso()
    existing = self._store["people"].get(key, {})
    self._store["people"][key] = {
        "name":       name,
        "age":        age,
        "relation":   relation,
        "likes":      likes or [],
        "notes":      notes,
        "last_seen":  existing.get("last_seen", now),
        "first_seen": existing.get("first_seen", now),
        "added":      existing.get("added", now),
    }

One thing I got wrong initially: I was storing names with their original casing in the face database but querying Hindsight with whatever case the recognition engine returned. This caused silent misses — the face would be recognized, the Hindsight lookup would return nothing, and the UI would show a name with no context. The fix was straightforward but important: normalize everything to lowercase at every write path. The face engine now lowercases all keys on load and on every add_person() call.

The Recognition Pipeline: Crop First, Embed Second

The other place I lost hours was "No face detected" errors from DeepFace. The original approach sent the full webcam frame directly to DeepFace.represent() — which works fine when the person is close and centered, and fails silently when they're not.

The fix was to introduce an OpenCV Haar cascade as a pre-processing step. The cascade detects the face first, crops it with 20% padding, and only then hands the region to DeepFace:

def _crop_largest_face(frame: np.ndarray) -> Optional[np.ndarray]:
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = _FACE_CASCADE.detectMultiScale(
        gray, scaleFactor=1.1, minNeighbors=5, minSize=(60, 60)
    )
    if len(faces) == 0:
        return None
    x, y, w, h = max(faces, key=lambda f: f[2] * f[3])
    pad_x, pad_y = int(w * 0.20), int(h * 0.20)
    return frame[
        max(0, y - pad_y):min(frame.shape[0], y + h + pad_y),
        max(0, x - pad_x):min(frame.shape[1], x + w + pad_x),
    ]

With enforce_detection=False on the cropped input (since the cascade already confirmed a face exists), DeepFace failure rates dropped dramatically. Separately, matching was improved by comparing the query embedding against the average embedding per person rather than against each stored sample individually — this reduces noise from outlier captures significantly.

The Suggestion Engine

Once a face is matched and memory is retrieved, the backend generates a conversation starter. The logic is layered:

Recency first: if the patient hasn't seen this person in over a month, say so — "You haven't seen Sarah in over a month. They might have news to share!"
Likes second: pick a random item from the likes list — "Ask Sarah about her painting class."
Notes keyword scan: if the notes mention "dog", "travel", "wedding", surface a relevant prompt.
Generic fallback: "Ask Sarah about their day."

def generate_suggestion(name: str, memory: dict | None) -> str:
    if not memory:
        return f"Ask {name} about their day"
    last_seen_dt = _parse_last_seen(memory.get("last_seen") or "")
    if last_seen_dt:
        delta_days = (datetime.now(timezone.utc) - last_seen_dt).days
        if delta_days >= 30:
            return f"You haven't seen {name} in over a month. They might have news to share!"
    likes = memory.get("likes") or []
    if likes:
        return f"Ask {name} about {random.choice(likes)}"
    ...

This is deliberately simple. The goal isn't to be clever — it's to give a patient a single, low-friction way to start a conversation without having to remember context they no longer have.

What a Real Interaction Looks Like

A caregiver sets up the laptop in the living room. The patient's daughter walks in. Within about one second:

The camera crops her face, generates an embedding, matches it against the database
The backend queries Hindsight for her memory record
The UI displays: Sarah · Daughter · 87% match
Below that: "Ask Sarah about her painting class"
The Web Speech API reads aloud: "This is Sarah, your daughter."

If someone completely new walks in, the UI shows an amber badge: "Unknown person detected." A caregiver can click "Add This Person," capture 5–10 photos from different angles using the in-modal webcam, fill in name, relationship, and notes, and the person is enrolled immediately. The next scan cycle will recognize them.

Lessons Learned

1. Memory is the product, recognition is the plumbing. Face recognition is a solved problem with off-the-shelf tools. What makes a system like this genuinely useful is the richness of the context layer. Invest there.

2. Normalize your keys at the boundary. The lowercase bug cost me a full afternoon. Any time you have two systems storing the same identifier (face DB and Hindsight in this case), pick a canonical form at the write path and never deviate from it.

3. Crop before you embed. Sending full frames to a model that expects a face is a reliability trap. A lightweight cascade detector as a pre-filter is cheap and it eliminates an entire class of errors.

4. Average embeddings beat per-sample matching. A single bad capture — eyes closed, bad angle — will skew your nearest-neighbor result if you're comparing against all stored samples individually. Averaging collapses noise. It's one extra line per person on load and it makes matching noticeably more stable.

5. Graceful degradation is a feature, not a fallback. The local JSON memory store isn't a hack — it's a first-class deployment mode. Some caregivers will not have API keys and will not create accounts. If your system requires a cloud service to function at all, you've locked out your most constrained users. Build the offline path properly from day one.

The codebase is available on GitHub. If you're building anything in the assistive technology space and want to talk through the memory architecture, I'm reachable. There's a lot more to do here — multi-patient support, mobile-first UI, more nuanced memory retrieval — but the core loop works, and the people it's designed for don't have time to wait for perfect.