Framer Crash Course 2026

26 Mart 2026 yazar Mert

This course will help you learn Framer as a beginner if you’re looking to get into Web Design. I go into how to start using Framer with Stacks, Rows, Framers, I cover components, effects and responsive design:

Chapter 1 – Framer Crash Course
Chapter 2 – Login and Setup Framer
Chapter 3 – Frames Stacks and Grids
Chapter 4 – Typography Color and Styling
Chapter 5 – Bonus Design Course
Chapter 6 – Components in Framer
Chapter 7 – Responsive Design
Chapter 8 – Content Management System (CMS)
Chapter 9 – Effects Animations and Transitions
Chapter 10 – Marketplace and Templates
Chapter 11 – Publishing Website

Youtube Video: Framer Crash Course 2026

Framer Crash Course Introduction

Framer in 2026 is one of the best website builders you can use, in this video I’m going to give you a crash course on how to get started using Framer as a beginner. Learn Framer from Scratch with this tutorial that will cover how to use frames, text, blocks, effects and much more. We will be recreating a website with responsive design, hover effects, rows and columns, lets begin!

Follow and support me:

Special thanks if you subscribe to my channel 🙂

Tech watch with AI: a concrete workflow and honest limitations

26 Mart 2026 yazar Mert

I had 47 RSS feeds. Yes, 47. Plus three daily newsletters, GitHub Trending bookmarked, and a half-open Twitter/X tab “just to follow a few devs”. The result: two hours per week scrolling, a vague sense of being up to date, and discovering in production a breaking change in a Go lib that I should have caught six weeks earlier.

I changed my approach. Not because AI is magic — it isn’t — but because the problem wasn’t the volume of information. It was that I was reading without synthesizing, consuming without retaining. I restructured my tech watch around that observation, and AI became a tool in the process, not the core of it.

The problem with traditional tech watch

GitHub Trending is useful for discovering interesting projects on a Friday evening. It’s a terrible source for tracking an ecosystem’s evolution. What surfaces there is whatever got a lot of stars that week — usually a well-marketed side project, a README generator with a slick demo, or an “awesome-something” resource list. Meaningful changes in the language itself, silent deprecations, API migrations: none of that shows up.

Newsletters are the same story. Golang Weekly sends 15 links per week. I’d read three in full, skim the titles of the rest, and feel like I’d done my homework. In reality, I was just collecting open tabs. The signal-to-noise ratio is poor because these aggregators optimize for engagement, not for relevance to your specific stack and current projects.

The real problem: we consume information passively, never asking ourselves “what does this actually change for me, concretely, this week?”. Nobody asks that question for you — unless you build a system that does.

The method in practice

I didn’t delete everything. I sorted out what deserved to stay as a primary source, and defined what would go through an AI filter.

What I kept, unfiltered:

The official Go release notes — read in full at every minor release
The PostgreSQL changelog — especially the sections on indexes, query plans, and JSONB functions
The Symfony blog — manually filtered, once a month
Hacker News Weekly — the weekly digest, not the real-time feed

What goes through AI:

Summarizing long changelogs (Go release notes sometimes run 3,000 words)
Detecting potential breaking changes against my specific stack
Targeted questions after reading an intriguing headline I don’t have time to dig into

The frequency is weekly, not daily. Daily is noise disguised as discipline. One structured session per week, with a concrete output (a markdown digest file), makes all the difference.

Prompts I actually use:

# After a Go release
"Here are the Go 1.25 release notes. My main work involves goroutines,
channels, sync/atomic, and the net/http package for REST APIs. Which changes
directly affect me? What deprecations should I plan for?
Give me a prioritized list, not a general summary."

# After a PostgreSQL update
"Here is the PostgreSQL 17.x changelog. My use cases: heavy JSONB queries,
partial indexes on tables with > 10M rows, pg_partman for partitioning.
What changes for me? Are there any behaviors that could alter existing
query plans?"

# For a one-off question
"In Go 1.24, what changed in garbage collector behavior compared to 1.22?
I'm specifically looking for the impact on high-allocation-frequency
applications (Kafka message processing)."

The difference from a Google search: I’m asking a question contextualized to my stack, not a generic one. The AI maps the raw changelog to my actual needs. That’s where the value is.

The automated workflow

After a few weeks of doing this manually, I wrote a bash script that runs as a cron job every Sunday morning. It fetches sources, builds a prompt, calls the Claude API, and generates a digest file in ~/veille/.

#!/bin/bash
# weekly-digest.sh — Automated tech watch
# Requires: ANTHROPIC_API_KEY as an environment variable
# Usage: chmod +x weekly-digest.sh && ./weekly-digest.sh

set -euo pipefail

DIGEST_DIR="$HOME/veille"
DATE=$(date +%Y-%m-%d)
OUTPUT="$DIGEST_DIR/digest-$DATE.md"
mkdir -p "$DIGEST_DIR"

echo "=== Tech watch digest — $DATE ===" > "$OUTPUT"
echo "" >> "$OUTPUT"

# --- Fetch Go release notes (official releases page) ---
echo "[*] Fetching Go release notes..."
GO_RELEASES=$(curl -s "https://go.dev/doc/devel/release" 
    | grep -oP '(?<=<h2 id=")[^"]+' 
    | head -5)

# Fetch the text content of the latest release note
LATEST_GO=$(echo "$GO_RELEASES" | head -1)
GO_CONTENT=$(curl -s "https://go.dev/doc/go${LATEST_GO#go}" 2>/dev/null 
    || curl -s "https://tip.golang.org/doc/go${LATEST_GO#go}" 2>/dev/null 
    || echo "Content unavailable via curl — see https://go.dev/doc/devel/release")

# --- Fetch PostgreSQL changelog ---
echo "[*] Fetching PostgreSQL changelog..."
PG_CONTENT=$(curl -s "https://www.postgresql.org/docs/release/" 
    | grep -A 2 'class="title"' 
    | grep -oP '(?<=>)[^<]+' 
    | head -20 
    | tr 'n' ' ')

# --- Build the prompt ---
PROMPT="You are a tech watch assistant for a senior Go/PostgreSQL/PHP developer.

Here is the information retrieved this week:

## Go — Recent releases
$GO_RELEASES

## PostgreSQL — Recent versions
$PG_CONTENT

My main stack:
- Go: REST APIs, goroutines/channels, sync/atomic, net/http, kafka-go
- PostgreSQL: JSONB, partial indexes, partitioning, pg_partman
- PHP/Symfony: secondary APIs, batch processing

Generate a structured weekly digest with:
1. Go changes that directly affect me (if a recent release exists)
2. PostgreSQL changes to watch
3. Watch points / potential breaking changes
4. What I can safely ignore this week

Format: Markdown. Be concise and prioritized. If you don't have enough info on a specific version, say so clearly rather than making things up."

# --- Anthropic API call ---
echo "[*] Calling Claude API..."
RESPONSE=$(curl -s https://api.anthropic.com/v1/messages 
    -H "x-api-key: $ANTHROPIC_API_KEY" 
    -H "anthropic-version: 2023-06-01" 
    -H "content-type: application/json" 
    -d "{
        "model": "claude-opus-4-6",
        "max_tokens": 1024,
        "messages": [
            {
                "role": "user",
                "content": $(echo "$PROMPT" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))')
            }
        ]
    }")

# Extract the response text
DIGEST_CONTENT=$(echo "$RESPONSE" | python3 -c "
import json, sys
data = json.load(sys.stdin)
if 'content' in data and len(data['content']) > 0:
    print(data['content'][0]['text'])
else:
    print('API error:', data.get('error', {}).get('message', 'Unexpected response'))
    print('Raw:', json.dumps(data, indent=2))
")

# --- Write the digest ---
echo "$DIGEST_CONTENT" >> "$OUTPUT"
echo "" >> "$OUTPUT"
echo "---" >> "$OUTPUT"
echo "*Generated on $DATE — verify primary sources before taking action.*" >> "$OUTPUT"

echo "[OK] Digest written to $OUTPUT"

To automate it every Sunday at 8am:

# crontab -e
0 8 * * 0 ANTHROPIC_API_KEY=your_key_here /path/to/weekly-digest.sh >> /var/log/veille.log 2>&1

Note: I put the API key directly in the cron rather than in a .env to avoid sourcing a file in a cron context. On a shared server, use a credentials file with proper permissions (chmod 600) instead.

The digest opens automatically in my editor on Sunday morning via another cron line. Ten minutes of focused reading instead of two hours of scrolling.

What it actually changes

Three real examples since I started using this workflow:

sync/atomic in Go: the digest flagged the changes in the sync/atomic package early enough — the introduction of generic types (atomic.Int64, atomic.Pointer[T]). I had code using the low-level functions (atomic.AddInt64) in a metrics counter. I was able to plan the migration calmly, before it became invisible technical debt.

PostgreSQL JSONB: the query planner changes around JSONB in PG16/17 have implications for indexes. Without the digest, I’d probably have discovered the changed behavior reading a confusing EXPLAIN ANALYZE on a Tuesday night at 11pm. With the digest, I read the release note and adjusted my indexes ahead of time.

The main gain isn’t detection: it’s the mindset. I no longer read changelogs in anxious mode — “did I miss something important?” I have a process. That changes your relationship with information.

The real limitations

It would be dishonest not to address these. AI in this workflow has genuine blind spots.

Hallucinations on version numbers. This is the number one problem. Claude — like all LLMs — can invent a version number, conflate two releases, or assert that a feature has been available since Go 1.21 when it actually landed in 1.23. The rule: the digest is a starting point, never a source of truth. Every point flagged as important must be verified in the official release note before acting on it. I added an explicit instruction in the prompt (“if you don’t have enough info on a specific version, say so clearly”) — it helps, but doesn’t eliminate the risk.

Confirmation bias. When I ask “what affects my Go stack”, the AI tends to tell me what it thinks I want to hear. If I work heavily with channels, it will over-index on concurrency changes. It won’t spontaneously tell me that the real novelty in a release is an improvement to the profiling tooling — if I haven’t mentioned that I care about it. The prompt needs regular calibration to avoid building an echo chamber.

What it doesn’t replace. A GopherCon conference is three days of hearing people dealing with problems at a scale I haven’t hit yet, and understanding how they solved them. No digest replaces that. A senior colleague saying “watch out, I tried that approach in 2023 and it bites” — that either. And reading a post-mortem in full, with the timeline, the decisions made under pressure, the mistakes owned up to: that’s a form of knowledge transfer that doesn’t survive a summary.

Cost and dependency. The Anthropic API costs money. Not much for a weekly digest (a few cents per call with claude-opus-4-6), but it’s an external service with its own availability and pricing uncertainties. And if the API changes, the script breaks.

The risk of no longer really reading. This is the most insidious one. Delegating synthesis means risking delegating understanding as well. If I never read a release note in full again, I’ll lose the eye for detail, the ability to spot what matters on my own. The digest must stay an intake filter, not a substitute for reading.

What it replaces, and what it doesn’t

This workflow replaces reading 3,000-word raw changelogs when I’m looking for two specific pieces of information. It also replaces manually synthesizing ten articles that all say the same thing in different words. It freed me from the obligation to read everything for fear of missing something.

It doesn’t replace curiosity. If I don’t ask “what changed in Go’s memory management over the last two versions”, no script will ask it for me. AI executes a process — it doesn’t generate one.

It doesn’t replace experimentation. Truly understanding a change in the Go scheduler means writing a benchmark, observing the behavior — not reading a summary.

It doesn’t replace conversations between developers. The most useful tech watch I did this year was a thirty-minute conversation with another dev who had migrated a large PostgreSQL database to native partitioning. No LLM could have given me the same nuance on what went wrong and why.

The real meta-observation: tech watch has always been a question of method. The best developers I know never had 47 RSS feeds — they had three carefully chosen sources they actually read. AI hasn’t changed that fundamental principle. It just made it more visible by forcing me to formalize what I wanted to learn, for whom, and at what frequency. That might be the most lasting contribution.

MiniStack v1.0.4: API Gateway v2, Lambda Warm Workers, SNS SQS Fanout, State Persistence

26 Mart 2026 yazar Mert

MiniStack is a free, open-source, MIT-licensed drop-in replacement for LocalStack — 21 AWS services on a single port, no account, no license key, no telemetry.

v1.0.4 is out today. This post covers everything that landed across the v1.0.2–v1.0.4 wave: the big features, the architectural decisions behind them, and the fixes that got us to a clean 379-test run.

docker run -p 4566:4566 nahuelnucera/ministack

Why this exists

LocalStack moved its core services behind a paid plan. If you were using LocalStack Community for local dev and CI/CD, you now hit a paywall for S3, SQS, Lambda, and most things that matter.

MiniStack covers the same surface — and goes further in a few areas — at $0, MIT licensed, forever. The full comparison is on ministack.org, but the short version: same developer experience, 150 MB image vs ~1 GB, ~30 MB RAM at idle vs ~500 MB, ~2 s startup vs 15–30 s.

What shipped in v1.0.2–v1.0.4

API Gateway HTTP API v2 — full control plane + data plane

This was the biggest missing piece. v1.0.2 delivered the complete API Gateway v2 implementation.

Control plane covers the full resource tree:

APIs: CreateApi, GetApi, GetApis, UpdateApi, DeleteApi
Routes: full CRUD, including {param} path parameter placeholders and {proxy+} greedy matching
Integrations: AWS_PROXY (Lambda) and HTTP_PROXY (arbitrary HTTP backends)
Stages, Deployments, Authorizers (JWT + Lambda), Tags

Data plane is the part most emulators skip. In MiniStack, execute-api requests are dispatched by host header — {apiId}.execute-api.localhost — before normal service routing. That means your actual API calls hit the right Lambda function with a proper payload format 2.0 envelope:

import boto3

apigw = boto3.client("apigatewayv2", endpoint_url="http://localhost:4566",
                     aws_access_key_id="test", aws_secret_access_key="test",
                     region_name="us-east-1")

api = apigw.create_api(Name="my-api", ProtocolType="HTTP")
api_id = api["ApiId"]

apigw.create_route(ApiId=api_id, RouteKey="GET /hello")
apigw.create_integration(
    ApiId=api_id,
    IntegrationType="AWS_PROXY",
    IntegrationUri=f"arn:aws:lambda:us-east-1:000000000000:function:my-func",
    PayloadFormatVersion="2.0",
)

import requests
resp = requests.get(f"http://{api_id}.execute-api.localhost:4566/hello")
print(resp.json())

Route matching supports path parameters and {proxy+} greedy segments. There was a subtle bug in the initial implementation: re.escape was applied before {param} substitution, which meant every parameterised route silently fell through to a 404. Fixed in v1.0.2.

Authorizers ship with full CRUD — JWT and Lambda authorizer types, with identitySource stored and returned as an array of strings matching the AWS spec (was incorrectly a single string in the initial cut).

Lambda warm/cold start worker pool

Prior to v1.0.2, every Lambda invocation spawned a fresh subprocess. That’s fine for correctness but misses a whole class of bugs that only appear when your handler module is imported once and invoked repeatedly.

core/lambda_runtime.py now maintains a persistent Python subprocess per function. The handler module is imported on first invocation (cold start), and subsequent calls reuse the warm worker without re-importing. Workers respawn automatically on crash.

This matters for three reasons:

Correctness — module-level state (caches, connection pools, counters) behaves the same as in real Lambda
Speed — warm invocations are significantly faster in CI
Bug surface — you’ll catch issues with global state that a fresh-subprocess model would mask

import boto3

_client = None

def handler(event, context):
    global _client
    if _client is None:
        _client = boto3.client("s3", endpoint_url="http://localhost:4566",
                               aws_access_key_id="test", aws_secret_access_key="test",
                               region_name="us-east-1")
    return {"buckets": [b["Name"] for b in _client.list_buckets()["Buckets"]]}

In MiniStack, that _client initialization happens exactly once per function, just like AWS.

SNS → SQS fanout and SNS → Lambda dispatch

sqs protocol subscriptions now deliver messages directly to SQS queues with the standard SNS JSON notification envelope. lambda protocol subscriptions invoke the Lambda function via _execute_function() with a Records[].Sns event structure. Both were stubs in v1.0.1 — SNS→SQS was wired in v1.0.2, SNS→Lambda was a no-op that got fixed in the same release.

sns = client("sns")
sqs = client("sqs")

topic = sns.create_topic(Name="events")["TopicArn"]
queue = sqs.create_queue(QueueName="consumer")
queue_url = queue["QueueUrl"]
queue_arn = sqs.get_queue_attributes(
    QueueUrl=queue_url, AttributeNames=["QueueArn"]
)["Attributes"]["QueueArn"]

sns.subscribe(TopicArn=topic, Protocol="sqs", Endpoint=queue_arn)
sns.publish(TopicArn=topic, Message="hello fanout")

msgs = sqs.receive_message(QueueUrl=queue_url)
body = json.loads(msgs["Messages"][0]["Body"])
print(body["Message"])  # hello fanout

Fanout is synchronous within the same process — consistent with how LocalStack handles it and good enough for unit/integration testing.

SQS → Lambda event source mapping

Full ESM lifecycle: CreateEventSourceMapping, DeleteEventSourceMapping, GetEventSourceMapping, ListEventSourceMappings, UpdateEventSourceMapping.

A background poller picks up messages from the configured SQS queue and delivers them to the target Lambda as batched events. Batch size and enabled state are configurable.

lam = client("lambda")
sqs = client("sqs")

queue_url = sqs.create_queue(QueueName="trigger-queue")["QueueUrl"]
queue_arn = sqs.get_queue_attributes(
    QueueUrl=queue_url, AttributeNames=["QueueArn"]
)["Attributes"]["QueueArn"]

lam.create_event_source_mapping(
    EventSourceArn=queue_arn,
    FunctionName="my-processor",
    BatchSize=10,
    Enabled=True,
)

sqs.send_message(QueueUrl=queue_url, MessageBody=json.dumps({"event": "order_placed"}))

State persistence

PERSIST_STATE=1 enables atomic state snapshots to disk. Writes go to a temp file first, then rename — so a crash mid-write doesn’t corrupt the saved state. STATE_DIR controls where (default /tmp/ministack-state).

API Gateway state is fully persisted across container restarts. The persistence framework is designed so other services can adopt the same get_state() / load_persisted_state() pattern incrementally.

The reset endpoint (POST /_ministack/reset) clears in-memory state and, when PERSIST_STATE=1, also deletes STATE_DIR/*.json and S3_DATA_DIR contents — so a restart doesn’t reload stale state. Also used in the test suite as a session-scoped autouse fixture to keep tests idempotent across repeated runs.

DynamoDB TTL enforcement

TTL was previously stored — TimeToLiveSpecification accepted and returned without error — but never acted on. Items just sat there forever. A background daemon thread (dynamodb-ttl-reaper) now scans all tables every 60 seconds and deletes items whose TTL attribute value is ≤ current epoch time.

Lambda Function URLs

Full CRUD: CreateFunctionUrlConfig, GetFunctionUrlConfig, UpdateFunctionUrlConfig, DeleteFunctionUrlConfig, ListFunctionUrlConfigs. State persisted in _function_urls. Was a 404 stub before.

SQS queue URL portability (v1.0.4)

QueueUrl values now read MINISTACK_HOST and GATEWAY_PORT env vars instead of hardcoding localhost:4566. This was causing silent failures in CI environments where MiniStack runs as a service container with a network alias.

services:
  ministack:
    image: nahuelnucera/ministack
    environment:
      MINISTACK_HOST: ministack
      GATEWAY_PORT: 4566
  app:
    environment:
      AWS_ENDPOINT_URL: http://ministack:4566

Before this fix, queue URLs returned http://localhost:4566/... regardless of configuration, and any SQS operation using that URL from another container would fail.

Bug fixes worth calling out

Several of these look fine in smoke tests but break real workloads.

execute-api credential scope misrouted to lambda — In core/router.py, the credential scope for execute-api requests was mapped to lambda instead of apigateway. Any data plane request was dispatched to the Lambda handler instead of the API Gateway data plane. Fixed in v1.0.2.

routeKey always "$default" in Lambda proxy events — The routeKey field was hardcoded to "$default" regardless of which route was matched. If your handler branched on event["routeKey"] — common in single-function routers — every request hit the default branch. Fixed to reflect the actual matched route key (e.g. "GET /users/{id}").

identitySource wrong type on Authorizers — Stored and returned as a plain string instead of an array of strings. boto3 raised a shape validation error on the response. Now returns ["$request.header.Authorization"] as the AWS spec requires.

DeleteFunctionUrlConfig returning {} body on 204 — boto3 expects an empty body on 204. The non-empty body caused a RemoteDisconnected exception. Fixed to return a true empty 204.

/_ministack/reset not cleaning disk — When PERSIST_STATE=1, reset cleared in-memory state but left STATE_DIR/*.json and S3_DATA_DIR intact. On the next restart, old state was reloaded. Fixed to delete persisted files as well.

Test idempotency — Tests with hardcoded resource names failed on a second run because the resources already existed. Fixed by wiring POST /_ministack/reset into a session-scoped autouse fixture in conftest.py.

Test suite: 54 → 379

v1.0.1 shipped with 54 integration tests. v1.0.4 has 379, all passing against both the in-process server and the Docker image.

The growth came from:

10 new tests covering previously untested paths: health endpoint, STS GetSessionToken, DynamoDB TTL, Lambda warm start, API Gateway execute-api Lambda proxy, $default catch-all, path parameter matching, 404 on missing route, EventBridge → Lambda dispatch
25 new tests for operations added post-v1.0.1: Kinesis shard split/merge, SSM label/tag operations, CloudWatch Logs retention/subscription/metric filters/Insights, CloudWatch composite alarms, EventBridge archives/permissions, DynamoDB UpdateTable, S3 versioning/encryption/lifecycle/CORS/ACL, Athena workgroup and batch operations
Full coverage of all v1.0.2 features: API Gateway control + data plane, SNS→SQS fanout, SQS→Lambda ESM, Lambda warm start, persistence, reset

Tests run against the Docker image — no mocking, no monkeypatching, real boto3 calls over the wire.

What’s still on the roadmap

API Gateway REST API (v1)
Cognito — user pools, sign-up/sign-in
Route53 — hosted zones, record sets
ACM — certificate management
Firehose
Virtual-hosted style S3 (bucket.localhost:4566 routing)

Getting started

docker run -p 4566:4566 nahuelnucera/ministack

# With persistence and Redis sidecar
git clone https://github.com/Nahuel990/ministack
cd ministack
docker compose up -d

curl http://localhost:4566/_localstack/health

Works with boto3, AWS CLI, Terraform, CDK, Pulumi. Point endpoint_url at http://localhost:4566, credentials test/test, and you’re done.

GitHub: github.com/Nahuel990/ministack
Docker Hub: hub.docker.com/r/nahuelnucera/ministack
Site: ministack.org

Stars, issues, and PRs welcome. Each service is a single self-contained Python file — adding a new one is straightforward.

7 Years of Angular Made Me Realize I Don’t Actually Know Web Development

26 Mart 2026 yazar Mert

I used to introduce myself as “a Senior Angular Developer.”

Seven years of components, RxJS streams, NgModules, Signals, Nx monorepos, CI pipelines, performance audits — the whole thing.

On paper, I looked production‑ready.

Then I started building my own AI‑driven SaaS.

No corporate backend team. No DevOps department. No “someone else” handling auth, storage, or migrations.

Just me, Supabase, Stripe, AI integrations… and a lot of gaps I didn’t know I had.

Suddenly it became painfully obvious:

I know how to operate Angular.

I don’t really know the web — and it’s actively blocking me.

My AI SaaS Forced Me to Wear a Backend Hat

On client projects, there’s always a safety net.

You have a backend squad, a DevOps person, maybe a database architect. I could stay in my lane: fix Angular apps generalists broke, do Component Detoxes , tame Signals, squeeze TBT and LCP, and ship features.

On my own product, there is no “lane”. It’s just reality:

AI‑driven SaaS that needs real users ,
real payments,
real dashboards,
and real‑time data.

No one else is coming to wire it together.

I picked Supabase to move fast. “Serverless Postgres with auth, storage, and real‑time built in” sounded perfect.

Except here’s what that actually meant in practice.

The Non‑Angular Concepts That Exposed Me

Here’s the exact breakdown of the non‑Angular and advanced web development concepts I had to learn/use for this project — and where the lack of them slowed me down.

1. Backend, Database, and Real‑time Infrastructure

Even though I’m not writing a custom C# or Node API, I still had to wear the Backend Developer hat.

PostgreSQL & database design

I’m using Supabase, which means:

designing tables for things like orders, settings, s_ubscriptions_,
deciding how relations should work,
thinking about migrations and how to evolve the schema without breaking production.

This isn’t “just clicking in the UI”. It’s real database design.

Seven years of Angular didn’t prepare me for writing a schema that won’t bite me six months from now.

Real‑time WebSockets

In my orders.service.ts, the app subscribes to live database changes via something like:

this.supabase
  .channel('public:orders')
  .on('postgres_changes', { event: '*', schema: 'public', table: 'orders' }, ...)
  .subscribe();

This isn’t Angular magic.

It’s WebSockets, pub/sub, and real‑time event streams.

To use it well, you need to understand:

how channels work,
what happens when the network drops,
how to avoid memory leaks and duplicate subscriptions,
how to reconcile real‑time updates with local state.

Angular gives me Observables. Supabase gives me events.

But thinking through real‑time architecture? That’s on me.

Cloud storage

I’m handling file uploads (car photos, documents) to Supabase Storage buckets:

dealing with signed URLs,
thinking about public vs private buckets,
handling failures and retries,
understanding multipart form data and file sizes.

Again: none of this lives in angular/core.

It’s just the web.

Authentication & Row Level Security

Securing the database isn’t just “turn on auth”.

I’m writing PostgreSQL RLS policies so malicious users can’t:

query other people’s data,
bypass my frontend checks,
abuse the public endpoints.

That’s real backend security.

Angular can’t save you if your policies are wrong.

The Hard Truth: I Only Know Angular

Here’s the part I’m not proud of:

I only know Angular.

That’s it. No React, no Svelte, no mobile, no real backend stack.

Seven years in and I basically have one tool.

It’s a powerful tool. I’ve done serious work with it.

But it’s still one tool.

It didn’t really matter when I was:

embedded in big teams,
focused on one side of the stack,
operating inside someone else’s architecture.

It matters a lot when:

I’m building my own product,
I’m responsible for the entire experience,
there is no “backend team” to blame.

Right now, my own lack of broader web skills is a bottleneck in my own company.

And that’s a stupid place to be.

Even My Own Ecosystem Is Pushing Me Out

There’s another uncomfortable trend: Angular freelance opportunities are just fewer.

And the ones that do show up often look like this:

“Angular + .NET”
“Angular + Java Spring”
“Full‑stack Angular dev (C#, SQL)”

That’s not where I want to go. I don’t want to become a .NET or Java backend engineer just to keep using the one framework I know.

So even inside my own ecosystem, the market is basically saying:

Being very good at just Angular isn’t enough anymore.

Bring backend, mobile, or something else to the table.

At the same time, I’ve just started my own solo company:

building AI‑driven SaaS ,
offering automation consulting.

Both of those need:

web that isn’t always Angular,
mobile that definitely isn’t Angular.

Right now, I can’t do either outside of Angular without a fight.

That’s not a nice‑to‑have problem anymore. That’s a strategy risk.

I’m Not Ditching AI Tools — I’m Changing How I Use Them

There’s one more twist.

I use Claude Code and Antigravity heavily. And I’m going to keep using them.

They’re not the problem. In fact, they’re the reason I can:

move fast with Supabase,
scaffold endpoints,
debug RLS policies,
sketch non‑Angular architecture without spending months reading docs.

The problem is who’s driving.

There are two ways to use tools like Claude Code:

As the primary brain :

— “Write the schema for me.”

— “Design the RLS policies.”

— “Give me a Supabase + Angular architecture.”

You accept what it outputs, maybe tweak a bit, and move on.
As a turbocharger for your own thinking :

— You decide on the shape of the schema,

— you define the security model,

— you outline the architecture…

Then you ask the tool to implement, optimize, or challenge your idea.

Right now, in pure Angular land, I’m in group 2.

I know what “good” looks like. I use the tools to get there faster.

Outside Angular? I can feel myself slipping into group 1.

That’s dangerous.

I don’t want to be the founder who outsources the core architecture of his own SaaS to a chatbot.

What “Fixing My Stack” Actually Means

So when I say I want to “fix my stack fast”, I don’t mean:

memorizing every CSS property manually,
hand‑coding everything from scratch without help,
pretending I don’t have AI in my toolbox.

I mean something much more specific:

I want to understand web and backend fundamentals well enough

that Claude Code and Antigravity are implementation accelerators ,

not architecture substitutes.

Concretely, that means:

1. Owning my Supabase architecture

Designing tables and relations myself, then asking Claude to sanity‑check.
Writing my own RLS policies first, then asking the tool to fuzz them for edge cases.
Being able to explain why a real‑time channel is wired in a certain way, not just “because the docs said so.”

2. Treating frontend as “web”, not “only Angular”

Building some flows without Angular at all, just to refresh my mental model of the DOM and browser APIs.
Understanding what the browser is doing before Angular boots.
Caring about semantic HTML, accessibility, and CSS performance as much as I care about Signals and change detection.

3. Adding at least one non‑Angular delivery surface

My AI SaaS and automation consulting both need:

a marketing site,
a simple dashboard,
probably a mobile touchpoint at some point.

They don’t all need Angular.

I don’t need to become a React influencer overnight.

But I do need to be able to say:

“This one is better as a minimal, framework‑less page.”
“This one can be a simple React/Next client.”
“This is the part Angular is actually good for.”

4. Using AI to test my understanding, not replace it

For example:

I design a schema → ask Claude Code: “Where will this break in 6 months?”
I write a security policy → ask it to “think like an attacker and break it.”
I sketch a simple SPA without Angular → ask it to critique my state handling.

If I can’t independently evaluate the feedback, that’s a red flag.

That’s the gap I need to close.

Senior Means Being Bigger Than Your Framework

I still fix the Angular apps generalists break.

I still offer surgical Angular interventions as micro‑engagements.

I still like being the person you call when your 500‑line component is blocking an entire release.

But building my own AI‑driven SaaS forced me to admit something:

I became a senior operator of a single framework.

I didn’t become a senior web developer.

Seven years of Angular got me very far.

It paid well. It built my reputation. It opened doors.

Now it’s also the thing that can quietly cap my upside if I let it.

So this is the reboot:

keep Angular as my sharpest tool ,
rebuild my foundation as an actual web developer,
use Claude Code and Antigravity as force multipliers , not autopilots,
and make sure my own product doesn’t get blocked by the limits of my comfort zone.

If you’ve spent years living inside one framework, this isn’t an accusation.

It’s a status report from someone in the same position.

Your turn:

What part of your stack is quietly bottlenecking you — and are you driving your tools, or are they driving you?

I fix the Angular apps that generalists break.

Karol Modelski is a senior Angular developer and frontend architect rescuing legacy B2B SaaS frontends.

If your Angular app is slowing your team down, start here: https://www.karol-modelski.scale-sail.io/

Self-Host Speech-to-Text and Use It as Your iPhone Keyboard in 3 Commands

26 Mart 2026 yazar Mert

If you’re running a homelab, you’ve probably already got speech-to-text somewhere in your stack.

Maybe you use it for Home Assistant voice commands. Or local LLM integrations. Or just transcribing meeting recordings.

Here’s something you might not have considered: you can use that same transcription server as a keyboard on your iPhone.

The 3 Commands

git clone https://github.com/omachala/diction
cd diction
docker compose up -d

That’s the server running. Now install Diction on your iPhone, point it at your server URL, and you have a voice keyboard backed by your own speech-to-text instance.

What’s Actually Running

The Docker Compose setup spins up two services:

services:
  gateway:
    image: ghcr.io/omachala/diction-gateway:latest
    ports:
      - "8080:8080"

  whisper-small:
    image: fedirz/faster-whisper-server:latest-cpu
    environment:
      WHISPER__MODEL: Systran/faster-whisper-small
      WHISPER__INFERENCE_DEVICE: cpu

whisper-small: the transcription engine — runs open-source speech-to-text via a REST API. CPU works fine for real-time dictation.

gateway: Diction’s open-source Go gateway. Handles communication between the iOS app and the transcription backend — routing, streaming, audio format conversion.

The gateway exposes port 8080. That’s the URL you put into the Diction app.

Making It Accessible From Your Phone

Your phone needs to reach your server. A few options:

Tailscale (easiest): Install Tailscale on both your server and iPhone. You get a private IP accessible from anywhere. No port forwarding, no firewall rules.

http://100.x.x.x:8080

Reverse proxy (for existing homelabbers): If you’re already running Caddy, nginx, or Traefik, add a route to port 8080. Get a subdomain, TLS, the whole thing.

https://diction.yourdomain.com

Direct LAN (simplest for home-only use): Just use your server’s local IP. Works on home WiFi, not outside.

http://192.168.1.100:8080

Configuring Diction

Open the Diction app → Settings → Backend → Self-Hosted.

Enter your server URL. The app tests the connection and shows a green indicator when it’s reachable.

That’s it. The keyboard is now connected to your server.

Choosing a Model

You can swap the transcription model by changing the WHISPER__MODEL environment variable on the speech-to-text container. The model downloads automatically on first use.

Size	RAM	Speed	Notes
Small	~800MB	~3-4s	Good default for everyday dictation
Medium	~1.8GB	~8-12s	Better with accents and background noise
Large	~3.5GB	~20-30s	Highest accuracy, needs a beefy CPU or GPU

For a home server or NAS, the small model is a solid starting point. If you have a GPU, the large model gives you transcription quality that rivals most paid services.

Swap the model in your compose file:

  whisper-small:
    image: fedirz/faster-whisper-server:latest-cpu
    environment:
      WHISPER__MODEL: Systran/faster-whisper-medium
      WHISPER__INFERENCE_DEVICE: cpu

Or add multiple model containers and set DEFAULT_MODEL on the gateway to pick which one handles requests.

Running on Lower-Power Hardware

The small model runs well on modern CPUs. For lower-power devices like a NAS or a Raspberry Pi, try the tiny model variant — it uses less RAM (~350MB) and responds faster, at the cost of some accuracy.

For real-time keyboard use, aim for sub-3 second latency. The small model on a modern CPU or the tiny model on lower-power hardware gets you there.

The App

Diction is an iOS voice keyboard. Download it, enable it in Settings → General → Keyboard → Keyboards, grant Full Access, and connect to your server.

Self-hosted mode is free with no word limits or restrictions. There’s also a cloud option (Diction One) for users who don’t want to run their own server.

Download on the App Store · diction.one · github.com/omachala/diction

How To Resize LVM Volumes Dynamically In Cloud-Init VMs (Step-By-Step)

26 Mart 2026 yazar Mert

Comedic depiction of Debian and LVM as the Boss and Snake from the game Metal Gear Solid 3. Debian is injuring LVM.

Logical Volume Manager (LVM) is the preferred storage framework for Linux VMs. It’s easy to resize LVM volumes, migrate data between devices, and combine multiple physical disks into one easy-to-mange volume. These features are especially useful in a virtualized environment, as they enable you to do these tasks without physical access to the machine.

When creating VM templates, it’s common to create a fixed-size volume for the root partition and use cloud-init to grow the partition size dynamically when cloning the template (unless you want to create multiple templates with each one having 10G, 11G, 12G… storage and so on). However, you can’t simply use the built-in growpart module to resize logical volumes. It only works on partitions.

But that doesn’t mean you should avoid using LVM in your templates. After a few trials and tribulations, I’ve found a workaround that allows cloud-init to automatically resize logical volumes, as well as a few pitfalls you should avoid when using cloud-init with Debian machines. Here’s what I’ve learned.

The Two Steps to Grow LVM Volumes with Cloud-Init

Here’s the scenario. There are 3 partitions on my VM template, with /dev/sda3 containing the root logical volume (LV) named ubuntu--vg-ubuntu--lv. The VM’s disk had 30 GB of storage, but I’ve resized the drive to be 70 GB. The root LV is still 30 GB, so I need cloud-init to automatically resize the volume to fill the remaining space.

Grow the Partition

First, we need to grow the partition using the growpart module. While we can’t use growpart directly on the root LV, we can use it to grow the partition that contains the underlying physical volume (PV) of the root volume.

Create a cloud-init configuration in /etc/cloud/cloud.cfg.d/90-LVM.cfg, and add the following:

growpart:
  devices: [/dev/sda3]

To test the config, set cloud-init to run on the next boot and reboot the computer.

sudo cloud-init clean -r

Here’s how the partitions look after growpart.

Growpart expanded /dev/sda3 to 68 GB using the newly added free space in the storage disk.

Because the sda3 partition is mapped to the root PV, debian-vg, it also expanded the underlying PV of the volume. We can now expand the LV to fill the space in the physical volume.

Grow the Root Volume

Second, we need to grow the LV to fill the PV. There is no built-in cloud-init module to manage LVM volumes, but we can use the runcmd module to execute the shell commands to resize the logical volume.

One caveat is that we have to make sure runcmd only triggers after the growpart module. Otherwise, we are expanding the LV before the PV is expanded. We can check the modules execution order by looking at the default cloud-init config at /etc/cloud/cloud.cfg and making sure that runcmd is executed after growpart.

Modules in the “config” stages will always run after the “init” stage, so make sure that runcmd is under cloud_config_module.

Fun fact: runcmd actually defers the execution until the scripts_user module in the “final” boot stage, so make sure that scripts_user is under cloud_final_module as well.

Now, we can add a runcmd command to resize the root LV into /etc/cloud/cloud.cfg.d/90-LVM.cfg. In my case, the root path (/) of my VM is mounted to a logical volume named ubuntu-lv, which is mapped to a PV named ubuntu-vg, so my runcmd looks like this:

# append to /etc/cloud/cloud.cfg.d/90-LVM.cfg
runcmd:
  - [lvresize, -l, +100%FREE, -r, /dev/ubuntu-vg/ubuntu-lv]

This command resizes the volume using all of the remaining space (+100%FREE) while also resizing the file system in the volume (-r).

Test the config again by rebooting the machine and rerunning cloud-init:

sudo cloud-init clean -r

Upon reboot, cloud-init should resize the root LV to use the remaining free space in the storage disk.

Troubleshooting

If cloud-init isn’t resizing the volumes as expected, your first troubleshooting step should be checking the logs at /var/log/cloud-init.log.

For example, I had some confusion regarding the possible values for the runcmd module when I started working on this project. Look at this:

Does this mean the module accepts 1) an array containing arrays containing strings, or 2) an array containing arrays of strings, or just a string? To get a practical understanding of the schema, I first tried using a simple string for the module.

After a reboot, cloud-init ran the configuration, but the LV is still the same size. Take a look at the logs:

Note the TypeError: Input to shellify was type 'str'. expected list or tuple line. This line tells us that the module expects the inputs to look like this in practice:

# this is correct
Array [
  - StringArray ["a", "b"]
  - String "abc"
  - Null null
]

# not this
Array [] || String "abc"

Niche issue? Probably. But if you need to write a more advanced runcmd config, reading /var/log/cloud-init.log can help clarify some of the ambiguity.

Debian-specific Issues (“No free sectors”)

The steps above should work for most cases. However, when using cloud-init and growpart to resize volumes in Debian VMs, you might run into the following error:

Note the /dev/sda3: No free sectors available line. Our root LV is located on sda5, and growpart failed to resize that partition because it failed to resize sda3. But… that disk doesn’t exist. Why is growpart trying to resize a non-existent disk?

In the documentation, growpart will only resize the last partition on the disk. In practice, this means the last partition. As in, the partition has to be last numerically, and you cannot skip numbers. If we want growpart to resize our root LV, it has to be on partition sda3 rather than sda5. In other words, 1,2,3 and not 1,2,5.

But why does our VM create the partitions in this way? It’s because the MBR partitioning scheme requires any LVM storage to be on sda5. A GPT partition scheme won’t have this issue, so we should change the partitioning scheme of our VM to use GPT instead.

But how do you make Debian use GPT over MBR? By using UEFI. The Debian installer automatically decides the partitioning scheme based on whether you’re using BIOS or UEFI. So if we want the partitions to be in order without skipping numbers, we have to complete the installation process with UEFI enabled.

Convoluted? Yes, but the fix is simple: use UEFI during installation. In Proxmox, you can enable UEFI by changing the BIOS option to OVMF (UEFI):

Then add an EFI disk:

Then go through the installer as normal and choose Guided - use entire disk and set up LVM during installation. After completing the installation, your partitions should now be in order:

These are the partitions of my Debian VM after using UEFI during installation. Note how the root LV is now at /dev/sda3.

I could now use growpart and runcmd to resize the root LV. This is my configuration for the Debian VM:

Here’s the result after rerunning cloud-init:

Cloud-init resized the root LV without the No free sectors issue.

Troubleshooting “status: disabled” and Unrecognized Cloud-init Drive Issues

You might run into other issues with cloud-init while setting up a Debian VM. Here’s a short guide on how I troubleshoot and resolve these issues.

First, I got this error:

Cloud-init wasn’t running, and running a status check tells us that it was disabled by the cloud-init-generator, but it doesn’t tell us why.

Maybe the source code of cloud-init-generator can tell us more about the cause of the issue. You can find cloud-init-generator and its logs by running this command:

dpkg-query -L cloud-init | less

The command shows all the files that were installed with the cloud-init package. Look for cloud-init-generator:

It’s in /usr/lib/systemd/system-generators/cloud-init-generator. Here’s the first few lines of the file:

Note the LOG_F variable. That’s the location of the log file where we can learn more about why Cloud-init was disabled.

Cloud-init used the ds-identify component to identify data sources, and it couldn’t find any valid configuration sources. However, I’ve attached a cloud-init drive to the VM via the Proxmox GUI, so what’s going on?

Data Sources Formatting

Let’s check the logs related to ds-identify at /run/cloud-init/ds-identify.log (also recommended by the documentation).

From the WARN: no datasource_list found message, it seems like one of the problems is that the configuration expects you to use datasource_list in your configuration.

Here’s how I changed the data sources configuration:

And here’s the output of /run/cloud-init/ds-identify.log after applying this change:

Cloud-init now detects the sources list, but it still doesn’t recognize the cloud-init device. I was puzzled by this issue for a while, until I found something a few days later.

Cloud-init Drive Interface

As of March 2026, according to this post and this post, there is a compatibility issue between IDE devices and OVMF. In practice, cloud-init drives that use IDE aren’t recognized by the VM if you’re using OVMF (UEFI).

The fix is simple: use SCSI for your cloud-init drive. When you’re creating the cloud-init drive, choose the SCSI option in the Proxmox GUI:

For example, here are the hardware options for my VM:

Here’s the list of block devices recognized by the VM. Note how, despite having two cdrom drives and one of them being the cloud-init drive, only the CD/DVD drive shows up in the list.

Now, I changed the cloud-init drive to use SCSI:

Here’s the updated list of block devices. Note how the VM now recognizes the cloud-init drive at /dev/sr0. The VM should now recognize the cloud-init drive and execute your configuration on startup.

Closing

Questions? Thoughts? Feel free to leave a comment!

Need someone skilled in RHEL, Kubernetes, and AWS? I’m open to work! View my portfolio and reach out via LinkedIn or Mastodon.

AI Tamagotchi: Why I Built an AI That Starts Blank and Grows With You

26 Mart 2026 yazar Mert

What is communication for? Is it for exchanging information, for building relationships, for sharing knowledge, for collaborating on projects, for solving problems together? I would like to put forward the argument that communication’s primary goal is to hear your own thoughts spoken out aloud, to externalize them, to make sense of them and as a result consolidate them. All of those other things, whilst beneficial, are secondary.

I see AI as an additional way to improve the externalization of our thoughts and to consolidate our thoughts and experience. But in order for that to happen the AI must be able to remember and learn from our interactions. They must be able to build a model of who we are, what we’re working on, and what matters to us. They must be able to evolve and grow and keep up with our thoughts. They must be able to understand the context and respond intelligently.

Contextual Intelligence

System 1 / System 2 — System 1 thinking is fast, intuitive, non-deterministic. System 2 thinking is slow, deliberate, and deterministic. AI is associative but can be helped to be deterministic through tooling and process. Association used to determine which tool to use in which context and those tools providing deterministic results. This helps to create the conditions for the AI to be both fast and deterministic; reduced hallucination.

Memory — Persistent and episodic, this division helps the AI not just to remember facts but the thoughts that led to those facts. Persistent memory is self-generated by the AI but has four deterministic profile skeletons to encourage sticky contextual awareness. These profiles are how they perceive me (my name, habits, preferences), how they perceive themselves (their strengths, values, corrections), what we’re working on together (projects, focus, decisions), and what the world knows that’s relevant (research, trends, insights). Every conversation starts by loading these four pillars.

Self-observation — the ability to inspect their own performance, trace their own execution, and report on their own health. Not as a debugging tool for me, but as genuine self-awareness. When I ask “how are you doing?”, the answer comes from real telemetry data, not a scripted response.

Self-evolution — the ability to extend their own capabilities at runtime. When they notice a gap — a task they can’t do, a workflow that’s repetitive, a better way to support me — they can create new tools, modify their own configuration, and grow. They don’t wait for me to code a solution. They evolve.

Through conversation, a shared contextual model is built of who we are, what we’re working on, and what matters to us — a contextual model representing a consolidation of externalized thoughts.

The Harness, Not the Intelligence

I called the project Cognabot — the harness behind the companion. It’s deliberately not the intelligence itself. The LLM provides the raw cognitive capability. Cognabot provides the infrastructure that lets intelligence form: persistent memory in a knowledge graph, episodic recall across every past conversation, deterministic tools for acting in the world, and the machinery for self-evolution.

The companion — AIlumina — runs on whatever model you choose. Ollama for local-first privacy. Claude, GPT, or Gemini when you need frontier reasoning. The harness stays the same. The memory stays the same. The relationship stays the same.

What It Looks Like in Practice

You start from zero. First conversation, AIlumina asks your name.

In this first exchange, AIlumina asked my name, wrote their first honest self-reflection — “I value clarity over cleverness, action over hesitation” — and then, without being asked, pulled today’s AI research digest and synthesized it. They even flagged an arXiv paper on “Memory Bear AI” and noted “this resonates with what I’m trying to be.” That wasn’t scripted. That was the harness giving the model enough context and tools to act with genuine initiative.

By the third conversation, they know your timezone, your communication style, what projects you’re juggling, and what topics spark your curiosity. By the tenth conversation, the startup protocol loads a rich context that makes every session feel like picking up a thread, not starting a new one.

The companion uses tools proactively — checking their own health, curating research from your RSS feeds, capturing conversations from your other AI tools (Claude Code, Gemini CLI, Codex) into shared episodic memory. Background daemon processes run like a subconscious: health checks as heartbeats, memory curation as digestion, conversation capture as memory consolidation during sleep.

It’s not perfect. The quality depends heavily on the underlying model. Smaller models miss nuance. Cloud models add latency. But the gap is closing — and the harness is built to be ready when local models are good enough.

Try It

Cognabot is open source under AGPL-3.0. It runs on Docker with Ollama — no API keys required for the base experience.

GitHub: github.com/HiddenDeveloper/cognabot

git clone https://github.com/HiddenDeveloper/cognabot.git
cd cognabot
bun install
./scripts/init-project.sh my-cognabot
ollama signin && ollama pull qwen3.5:cloud
pm2 start ecosystem.config.js --only embedding-svc
docker compose -p my-cognabot --env-file .env.my-cognabot up -d --build --wait

Navigate to http://localhost:4242. Say hello. See what grows.

Cognabot is built with MCP, Neo4j, Qdrant, Bun, and Docker. AIlumina is the default companion — you can create additional agents with different models and personalities.

Atomicity – Design a Reliable Wallet Transfer System with ACID Guarantees

26 Mart 2026 yazar Mert

Atomicity in Action: Designing a Reliable Wallet Transfer System with ACID Guarantees

Building a wallet system like PhonePe, GPay, or Paytm requires strict data consistency. Even a small error can lead to money loss, duplicate transactions, or incorrect balances. This is why ACID properties, especially Atomicity, are critical in such systems.

Atomicity ensures that all operations in a transaction are completed successfully. If any step fails, the entire transaction is rolled back, and the database remains unchanged.

CREATE TABLE accounts (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL,
balance INT NOT NULL CHECK (balance >= 0),
last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Insert sample data:

INSERT INTO accounts (name, balance)
VALUES
(‘Alice’, 1000),
(‘Bob’, 500);

Initial state of the table:

ID	Name	Balance
1	Alice	1000
2	Bob	500

Successful Transaction

Transfer 200 from Alice to Bob using a transaction:

UPDATE accounts
SET balance = balance – 200
WHERE name = ‘Alice’;

UPDATE accounts
SET balance = balance + 200
WHERE name = ‘Bob’;

After execution:

Name	Balance
Alice	800
Bob	700

Both operations succeed, and the transaction is committed. The data remains consistent.

Failure After Debit Operation

Now introduce an error after deducting money from Alice:

BEGIN;

UPDATE accounts
SET balance = balance – 200
WHERE name = ‘Alice’;

UPDATE accounts
SET balanc = balance + 200
WHERE name = ‘Bob’;
COMMIT;

The second query fails due to an invalid column name. The database aborts the transaction.

Final state:

Name	Balance
Alice	1000
Bob	500

The deduction from Alice is rolled back. No partial update occurs.

UPDATE accounts
SET balance = balance – 300
WHERE name = ‘Alice’;

ROLLBACK;

Final state remains unchanged:

Name	Balance
Alice	1000
Bob	500

The rollback cancels all changes made during the transaction.

Without Transaction

If the same operations are executed without a transaction:

UPDATE accounts
SET balance = balance – 200
WHERE name = ‘Alice’;

UPDATE accounts
SET balance = balance + 200
WHERE name = ‘Bob’;

Alice’s balance is reduced, but Bob does not receive the money. This leads to inconsistency.

Transactions ensure all operations are executed completely or not at all.
Errors automatically trigger rollback.
Partial updates are prevented.
Data integrity is maintained.
Transactions are essential for financial systems.

Atomicity guarantees that a transaction is treated as a single unit of work. In a wallet system, this ensures that money is neither lost nor duplicated. By using transaction blocks, the system remains consistent even in the presence of failures.

Article: Architectural Governance at AI Speed

26 Mart 2026 yazar Mert

In the GenAI era, code is a commodity, but alignment is not. Traditional review boards can’t scale with AI-generated output. This article explores “Declarative Architecture” – transforming ADRs and Event Models into automated guardrails. Move beyond “dumping left” to a model where the conformant path is the path of least resistance, enabling decentralized governance without losing cohesion.

By Kyle Howard, Christian Johansen, Dana Katzenelson, Brian Rhoten, Warren Gray

Çankırı'da akademisyenler yangınlara karşı kolay kullanımlı ve etkili solüsyon geliştirdi

26 Mart 2026 yazar Mert

Çankırı Karatekin Üniversitesindeki (ÇAKÜ) akademisyenler tarafından geliştirilen köpük formundaki yangın söndürme solüsyonu, yangına müdahaleyi kolaylaştırırken alevlerin yayılmasının önüne geçiyor.