Originally published on wow-themes.com. If you're building a custom Gutenberg block and the editor suddenly says "This block contains unexpected or invalid content", this post explains why it happens and how to add dynamic classes and conditional markup without triggering it. For new block developers the error is confusing. You change something small, like adding a wrapper or setting a CSS class from an attribute, and every existing block on the page breaks. I'll use a real example to show what's going on: an offcanvas drawer block whose handle can be a button or an image, and which opens from the left, top, right or bottom. The goal A custom offcanvas drawer block in the block editor. The user chooses where the drawer opens from: left, right, top or bottom. The handle is either a button or an image. The drawer content accepts nested (inner) blocks. Simple on paper. The trouble is all in the validation logic. How block validation actually works A static block stores its HTML in the post content. When the editor opens that post, WordPress takes the block's saved attributes, runs your save() function again, and compares the result with the HTML stored in the database. If they don't match, the editor can't be sure it understands the markup, so it marks the block as invalid instead of silently overwriting it. The Block Editor Handbook's section on validation has the details. That's why the error usually shows up when: you change save() after posts were already saved with the old markup, save() outputs something that differs between runs for the same attributes, or save() renders a component from @wordpress/components, which is built for the editor UI, not for saved markup. edit() is never part of the comparison. It only controls what you see while editing. The problem in our example The block attributes: "attributes": We tried to render the handle like this: <Button className="offcanvas-drawer-handle"> <img src={attributes.handleImage.url} alt="" /> Button> The moment that
I build Sottava, a job board for engineers that reads about 2,100 company hiring systems every hour. This week I shipped a practice interview, and I tried it first on a real Frontend Engineer (React) posting. I answered "I don't know" to 7 of the 10 questions. The report said: Apply after brushing up. That was the point. A practice interview that only flatters you is useless the day before the real one. Questions from the posting, not a question bank The model reads the posting and your CV and writes 10 questions in three parts: A warm-up about your recent work. Five on what this posting asks for. Each one shows the line of the posting it comes from, and the code checks that the quote really appears in the posting before showing it. Four harder ones: two practical scenarios, working with others, and a mistake you made. Feedback you can read between questions After each answer you get one line on what came through and one on what is missing, plus what a strong answer to this question would cover. When something important is left open, the interviewer asks one follow-up, never more. "I don't know" is an answer Real interviews have questions you can't answer. Here, "I don't know" shows what the interviewer wanted to hear and an honest way to say you haven't done it, from what your CV does show. It never invents experience for you. From gaps to a study plan Every "I don't know" becomes a study page: a few YouTube videos and the right pages of the docs. The links come from a web search, and every one is checked before it is shown: YouTube through its oEmbed endpoint, pages by actually opening them. From memory, the model got 0 or 1 real video IDs per topic, so the check is not optional. The verdict At the end you get a short answer to the question people actually have: is this job worth applying for, and why, judged only from your answers against the posting. No job in mind yet? There is a general practice built from your CV alone, for the role it points to. Numbers A full session is about $0.05 in model calls, so the first practice is free, report included. Try it on a job you actually want: https://sottava.com/jobs. I read every piece of feedback.
Passwords get phished, reused and leaked. Passkeys (built on the W3C WebAuthn standard) fix that: the private key never leaves the user's device, every login is bound to your domain, and users sign in with a fingerprint, face or PIN. The hard part is the server side. You have to decode CBOR and COSE keys, parse X.509 certificates, check origins, challenges, flags and signature counters, and get every one of those checks right. I built @xkid1/webauthn to handle all of that in one package. It's a zero-dependency, security-first WebAuthn / passkeys library written in strict TypeScript, and it runs in browsers, Node.js, Deno, Bun, Cloudflare Workers, Electron and React Native (Android). xkid1 / webauthn Zero-dependency, security-first WebAuthn / passkeys toolkit for browsers, Node.js, Electron and React Native (Android). Client ceremonies, server verification and Android Credential Manager bridge. @xkid1/webauthn Zero-dependency, security-first WebAuthn / passkeys for every runtime: browsers, Node.js, Electron, React Native (Android) and edge workers. Written in strict TypeScript. Zero runtime dependencies. It ships its own CBOR, COSE, ASN.1/X.509, base64url and UTF-8 code, built only on WebCrypto. Small and tree-shakeable. It is pure ESM with sideEffects: false and separate /client, /server and /android entry points. The client entry is about 10 kB gzipped. Secure by default. It enforces exact origin allowlists, checks challenges in constant time, and makes every challenge single-use. It checks the RP ID hash, UP/UV and BE/BS flags, the algorithm allowlist, signature counters (clone detection) and the 1023-byte credential-ID limit. Its parsers have bounds checks, depth limits and length-bomb protection. Customisable. Every setting has a safe default you can override: algorithms, UV policy, attestation policy and trust anchors, counter policy, timeouts, cross-origin rules, plug-in attestation verifiers, an injectable WebCrypto and clock, a custom… View on GitHub Why another WebAuthn library? Zero runtime dependencies. CBOR, COSE, ASN.1/X.509, base64url and UTF-8 are all implemented in the package, on top of WebCrypto only. No transitive supply chain to audit. Small and tree-shakeable. Pure ESM, sideEffects: false, and separate /client, /server and /android entry points. startRegistration + startAuthentication is about 4.2 kB brotli. Secure by default. Exact origin allowlists, constant-time challenge comparison, single-use challenges, RP ID hash checks, UP/UV and BE/BS flag checks, an algorithm allowlist (RS1 is never accepted), RSA ≥ 2048 bits, signature counter clone detection, and strict, bounds-checked parsers. WebAuthn Level 3. JSON serialisation, hints, passkey autofill (conditional mediation), auto-register (conditional create), getClientCapabilities() and the Signal API. Every attestation format. packed, tpm, android-key, android-safetynet, fido-u2f, apple and none are verified out of the box. Runs everywhere and is SSR-safe. Importing it never touches window, so it works with React, Next.js, Vue, Nuxt, Angular, SvelteKit, Solid and Electron. Install npm i @xkid1/webauthn # or: yarn add @xkid1/webauthn / pnpm add @xkid1/webauthn Entry point Use it in @xkid1/webauthn/client Browser, Electron renderer, WebView @xkid1/webauthn/server Node.js ≥ 20, Deno, Bun, Cloudflare Workers @xkid1/webauthn/android React Native / native Android (Credential Manager bridge) How to add passkey login: the server (Node.js) A passkey flow has two ceremonies, registration and authentication. Each is one request for options and one request to verify. Here's the whole server with Express: import { createWebAuthnServer, MemoryChallengeStore } from '@xkid1/webauthn/server'; verifyRegistration returns plain JSON-friendly values (id, publicKey, counter, transports, deviceType, backedUp, aaguid…), so you can store them in any database without extra encoding. The challenge is stored server-side under sessionKey and deleted the moment it's used, so a replayed response fails. If you'd rather manage challenges yourself, pass expectedChallenge instead. How to add passkey login: the browser On the client, createWebAuthnClient calls the four endpoints above for you: import { createWebAuthnClient, isWebAuthnSupported } from '@xkid1/webauthn/client'; Already have an HTTP layer? Use the low-level functions instead: import { startRegistration } from '@xkid1/webauthn/client'; await api.post('/webauthn/register/verify', { response }); Passkey autofill (conditional mediation) in React Show saved passkeys right in the username field's autofill menu: 'use client'; import { useEffect } from 'react'; import { cancelCeremony, isConditionalMediationAvailable, startAuthentication, } from '@xkid1/webauthn/client'; export The repository has the same recipe for Vue/Nuxt, Angular, Svelte/SvelteKit and Electron. Passkeys in React Native (Android) React Native has no navigator.credentials; Android passkeys go through Jetpack Credential Manager. The /android entry point handles the JavaScript side (JSON normalisation, validation and error mapping), and you supply a small native module: import { NativeModules } from 'react-native'; import { createAndroidPasskeyClient } from '@xkid1/webauthn/android'; On the server, allow the app's signing-key origin and serve Digital Asset Links: import { androidOriginFromFingerprint, buildAssetLinks } from '@xkid1/webauthn/android'; // SHA-256 of your app's signing certificate createWebAuthnServer({ rpId: 'example.com', rpName: 'Example', origins: ['https://example.com', androidOriginFromFingerprint(FP)], }); The README includes a ~40-line Kotlin module you can copy. Errors you can actually act on Every failure is a single WebAuthnError type with a stable code and a hint that tells you how to fix it: import { isWebAuthnError } from '@xkid1/webauthn/client'; catch (e) { // user cancelled throw e; } Messages and hints never include challenges, keys, signatures or user handles, so they're safe to log. On the server, error.toJSON() returns { name, code, message, hint } without the stack, ready to send back from an API. Secure defaults, customisable when you need it Every option has a safe default, and options can only make verification stricter or opt in explicitly. None of them loosens a check silently. import { createAndroidKeyVerifier, createWebAuthnServer } from '@xkid1/webauthn/server'; origins: ['https://example.com'], supportedAlgorithms: [-8, -7, -257], // EdDSA, ES256, RS256 (the default) requireUserVerification: true, attestation: 'direct', trustAnchors: [appleWebAuthnRootDer], requireTrustedAttestation: true, attestationVerifiers: { 'android-key': createAndroidKeyVerifier({ requireTeeEnforced: true }), }, You can also plug in your own challenge store (Redis, a database), your own attestation verifiers, an injected WebCrypto, or a custom clock for tests. How it's tested A software authenticator produces real signed ES256, EdDSA and RS256 responses, so tests exercise actual cryptography instead of canned fixtures. Negative tests for every security check: each tampered input must be rejected with the right error code. End-to-end tests against the packed tarball. CI builds the package, installs it offline into a fresh app (which fails if it has any dependency), and runs registration and sign-in over real HTTP. A separate CBOR encoder is used there so the library never verifies data it encoded itself. Bundle-size budgets enforced in CI, plus benchmarks in Node, Bun, Deno, Chromium, Firefox and WebKit. Verification is fast too: about 5,000 registrations/s and 2,500 sign-ins/s on Node 26. FAQ What is the difference between WebAuthn and passkeys? WebAuthn is the W3C browser API and protocol for public-key authentication. A passkey is a discoverable WebAuthn credential, usually synced across a user's devices by Apple, Google or a password manager. @xkid1/webauthn supports both synced passkeys and device-bound security keys. Does it support FIDO2 and FIDO U2F security keys? Yes. FIDO2 is WebAuthn plus CTAP2, and @xkid1/webauthn is a FIDO2 relying-party library: it creates the options and verifies the responses from any FIDO2 authenticator, such as a YubiKey, Touch ID, Windows Hello or an Android phone. Older FIDO U2F (CTAP1) security keys also work through WebAuthn, and their fido-u2f attestation is verified. Credentials registered with the legacy U2F JavaScript API (appid extension) aren't supported, so users re-register those keys once. Does it work with Next.js, Nuxt and other SSR frameworks? Yes. Importing the package never touches window or navigator, so it's safe in server components and SSR. Call the client functions from the browser only. Can I use it on Cloudflare Workers, Deno or Bun? Yes. The server entry point only needs globalThis.crypto (WebCrypto), with no node:* imports and no Buffer. Do I need attestation? Usually not. The default, attestation: 'none', is the most privacy-friendly choice and fits most consumer apps. Turn on direct attestation with trustAnchors only if you need to know which authenticator model created a credential, for example in enterprise deployments. Does it support iOS? In Safari and WKWebView, yes, through the /client entry point. For React Native on iOS, bridge to ASAuthorizationPlatformPublicKeyCredentialProvider; the server side is identical. Try it git clone https://github.com/xkid1/webauthn.git cd webauthn && yarn install && yarn demo Open http://localhost:5173 to register a passkey, sign in, try passkey autofill, and change every registration and authentication option from the Advanced Settings panel. 📦 npm: @xkid1/webauthn 💻 GitHub: xkid1/webauthn 🔐 Spec: W3C WebAuthn Level 3 It's MIT-licensed and at v0.1.0. Feedback, issues and stars are very welcome. If you add passkeys to your app with it, tell me in the comments! 🚀
remove.bg's standalone site and self-serve API close on 1 December 2026. Every call to https://api.remove.bg/v1.0/removebg stops working that day, including the npm and PyPI wrappers, remove.bg's CLI and the shop plugins built on it. I built Cutmatte, an API that takes the same requests. Migration is two changes: - https://api.remove.bg/v1.0/removebg + https://api.cutmatte.com/v1.0/removebg X-Api-Key: your Cutmatte key Try it with a free preview: curl -H "X-Api-Key: $CUTMATTE_API_KEY" \ -F "image_file=@photo.jpg" -F "size=preview" \ -o result.png https://api.cutmatte.com/v1.0/removebg What stays the same Endpoints, parameters (size, type, format, crop, scale, position, bg_color, bg_image_url, roi, channels, shadow_type=drop), response formats (PNG, JPG, WebP, ZIP, JSON base64), headers and error codes. Tested with the npm remove.bg 1.3.0 package, PyPI removebg 0.4, remove.bg's CLI and the samples from its API page: 34 of 34 checks pass. What is different No 3D or car shadows (a documented 400), type=auto reports other, and the first request after a quiet period takes 15–35 s while a GPU starts, so use a 60 s timeout. Results differ from photo to photo: run your own typical images through the free previews (50 a month) before you switch production. Checklist before 1 December Search code, env vars, CI secrets and no-code tools for api.remove.bg. Record your remaining remove.bg credits: a screenshot is enough for free Cutmatte credits, up to 1,000. Download invoices from your remove.bg account while you can. Point one environment at the new URL and run your usual images through it. Guide with Node.js, Python, PHP and Ruby examples: https://cutmatte.com/migrate/
Shading analysis improves solar panel layout design accuracy by quantifying how much energy is blocked by obstructions, so row spacing, tilt, string grouping, and inverter choices rest on calculated losses instead of estimates. It replaces assumptions with hour-by-hour irradiance data, which keeps yield predictions and electrical designs aligned with real site conditions. The biggest gains […] The post How does shading analysis improve solar panel layout design accuracy? appeared first on Power Wattz Solar | Off Grid Solar Solutions | Battery Backups.
I've been exploring an interesting question: Can we borrow progression mechanics from games to make everyday productivity more engaging? That exploration resulted in Brickday — a browser-based productivity application that transforms task completion into a simple progression system. Instead of just maintaining a to-do list, users earn experience points, progress through levels, build activity streaks, and redeem custom rewards. The application is now live. Live Demo: https://sadique010.github.io/Brickday/ Product Overview Brickday is built around three primary modules. 1. Task Management and XP Allocation Users can create tasks with a title, description, difficulty, and recurrence schedule. The application supports three difficulty levels: Difficulty XP Easy 10 Medium 15 Hard 20 When a task is completed, the corresponding XP is awarded. Other functionality includes: Creating, editing, and deleting tasks. Pending and completed task views. Daily and weekly recurring tasks. Completion confirmation and a time-limited undo mechanism. 2. Custom Reward Economy Users can define their own rewards and assign an XP cost to each. The reward system uses two separate values: earned: Total lifetime XP accumulated. spent: Total XP redeemed through rewards. The available balance is calculated as: balance = earned - spent This separation is important because level progression depends on lifetime XP rather than the remaining spendable balance. Redeeming a reward therefore affects the available balance without reversing level progression. 3. Profile and Activity Tracking The profile module provides an overview of user progression. It includes: Current level. XP progress toward the next level. Lifetime XP earned. Total tasks completed. Current activity streak. Recent reward redemption history. Monthly activity heatmap. These statistics are derived from the application's persisted state. Implementing the Level Progression I wanted a progression curve that was simple to understand but gradually increased the effort required to advance. The level threshold is calculated using: The application determines the current level by comparing lifetime XP against successive thresholds. For example: Level 1: 0 XP Level 2: 50 XP Level 3: 150 XP Level 4: 300 XP Level 5: 500 XP The progress bar then calculates the user's position between the current and next level thresholds. Handling Recurring Tasks Recurring tasks introduce an additional state-management challenge. A task should be completed only once within its recurrence period, but it should become available again when that period ends. Brickday supports: Daily recurrence. Weekly recurrence, using Sunday as the start of the week. Each recurring task tracks the period in which it was completed. When the current period changes, completed recurring tasks are reset. This allows the same task to contribute to progression again in a subsequent period. Technology Stack I deliberately kept the project lightweight. Technology Purpose HTML5 Document structure CSS3 Styling and responsive layout React 18 Component-based UI HTM JSX-like templating React Hooks State and lifecycle management LocalStorage Client-side persistence The application is currently contained in a single HTML file. React, ReactDOM, and HTM are loaded through CDNs, so there is no build process or package installation required. Data Persistence Brickday currently uses browser LocalStorage for persistence. The application stores its state under: The persisted state includes tasks, rewards, activity records, lifetime XP, spent XP, and redemption history. This makes the application easy to run and deploy without a backend. There are also some deliberate limitations in the current implementation: No user authentication. No cloud database. No cross-device synchronisation. Progress is tied to the browser's local storage. These are important considerations for any future expansion. Design Decisions I wanted the interface to have a distinct visual identity rather than resemble another conventional SaaS dashboard. The design uses: Bricolage Grotesque typography. A soft, colourful visual palette. Strong borders and offset shadows. Difficulty-based task card colours. Responsive layouts. Reduced-motion support. The objective was to make the interface approachable while keeping the actual workflow straightforward. What's Next? Brickday is an early product experiment. The larger question I'm interested in exploring is how game-inspired mechanics can support consistent behaviour without turning productivity into another source of pressure. There is a fine line between making progress rewarding and making users optimise for points instead of meaningful work. That's a design problem worth exploring. Try It Out Live application: https://sadique010.github.io/Brickday/ I'd appreciate feedback, particularly on the progression system, XP economy, and overall user experience. Discussion: Do you think gamification can meaningfully improve personal productivity over the long term, or does it eventually become another layer of distraction? Thanks for checking out Brickday! webdev #react #javascript #productivity #buildinpublic
Bay Area homeowners will need to replace broken natural gas furnaces with heat pump heating and cooling systems starting in 2029 — at a median extra cost of about $12,500, according to a new analysis. That is the second natural gas ban imposed by the Bay Area Air District, which wants major…
Deploying WordPress on AWS with a 3-Tier Architecture Hosting WordPress on one server works until that server crashes, traffic spikes, or the database is exposed to the internet. This article walks through how I built WordPress the way real companies do: a secure, scalable 3-tier architecture on AWS, step by step and in plain language. The project is split into six parts, which this article follows in order: Project Overview Networking Setup: create a V Networking Setup: create a NAT Gateway and security groups Database Setup: create a MySQL database and EFS in AWS Compute Setup: set up EC2 instances and an Application Load Balancer Conclusion and Clean-up What is a 3-tier architecture? A 3-tier architecture splits an application into three layers, and each layer has one job. Think of a restaurant: customers meet the host at the door, the kitchen prepares the food, and the storage room keeps the ingredients. Customers never walk into the kitchen or the storage room. Tier Restaurant analogy In this project Presentation The front door and host Application Load Balancer in public subnets Application The kitchen Two EC2 instances running WordPress in private subnets Data The storage room Amazon RDS (MySQL) in private subnets This separation is what makes the design secure and reliable. Only the Load Balancer faces the internet, so the servers and the database cannot be reached directly from outside. Part 1: Project Overview The goal is a live WordPress website that stays available if one server or one data centre fails, and that keeps its servers and database hidden from the public internet. The build has five main pieces: • Network setup: a VPC with 2 public and 4 private subnets. An Internet Gateway gives the public subnets internet access, and 2 NAT Gateways in the public subnets give private resources outbound-only access. • Load balancing: an Application Load Balancer (ALB) receives visitor traffic and spreads it across the servers. • Compute layer: two EC2 instances in private subnets host the WordPress application. • Database layer: an Amazon RDS MySQL instance in the private subnets stores the site data. • Routing and security: route tables and security groups control which traffic may flow where. Visitors enter through the Internet Gateway and reach the Load Balancer, which forwards requests to the WordPress servers. The servers use EFS for files and RDS for data, and the NAT Gateways give the private subnets outbound-only access. Services used Service What it does here Category Amazon VPC Isolated network with subnets, route tables and NAT Gateways Networking Internet Gateway Gives public subnets access to the internet NAT Gateway Lets private instances download updates without being exposed Application Load Balancer Distributes incoming traffic across the EC2 instances Load balancing Amazon EC2 Runs the WordPress application Compute Amazon RDS Managed MySQL database for WordPress data Database Amazon EFS Shared file storage so both servers see the same WordPress files Storage IAM roles and policies Secure permissions between AWS services Permissions Route tables Direct traffic between subnets, gateways and the internet Security groups Fine-grained firewall rules for each resource Security What the finished project delivers • A live WordPress website reachable through the ALB DNS name • Secure traffic routing, with EC2 instances kept in private subnets • An integrated Amazon RDS database for dynamic content • A scalable, production-style 3-tier architecture Part 2: Networking Setup, VPC with Public and Private Subnets The VPC (Virtual Private Cloud) is your own isolated network inside AWS, and every other resource in this project lives inside it. I split it into 2 public and 4 private subnets, spread across two Availability Zones so that an outage in one zone does not take the site down. The CIDR ranges below are an example layout. Use any non-overlapping ranges you prefer. Subnet Type Availability Zone Purpose Example CIDR public-1 Public AZ 1 Load Balancer, NAT Gateway 10.0.1.0/24 public-2 AZ 2 10.0.2.0/24 private-app-1 Private EC2 instance running WordPress 10.0.3.0/24 private-app-2 10.0.4.0/24 private-db-1 RDS database 10.0.5.0/24 private-db-2 10.0.6.0/24 Steps Create the VPC. In the VPC console, create a VPC with a CIDR block such as 10.0.0.0/16 and give it a clear name tag. Create the six subnets. Create each subnet from the table above, choosing the right Availability Zone for each one. Create and attach an Internet Gateway. The Internet Gateway (IGW) is the door between the VPC and the internet. Attach it to your VPC. Create a public route table. Add a route sending 0.0.0.0/0 to the Internet Gateway, then associate this route table with the two public subnets. A subnet is only "public" because its route table points to the Internet Gateway. The private subnets have no such route, which is why nothing on the internet can reach them directly. The private subnets still need to download packages and updates, which is what the NAT Gateways in the next part are for. Part 3: Networking Setup, NAT Gateways and Security Groups Private servers cannot be reached from the internet, but they still need to go out to it for software updates and WordPress packages. A NAT Gateway allows outbound connections from private subnets while blocking inbound ones. Security groups then act as firewalls around each layer. Create the NAT Gateways Allocate two Elastic IP addresses, one for each NAT Gateway. Create a NAT Gateway in each public subnet, so there is one per Availability Zone. If one zone fails, the other zone's servers keep their outbound access. Create two private route tables, one per Availability Zone. In each, add a route sending 0.0.0.0/0 to the NAT Gateway in the same zone. Associate each private route table with the private subnets in its zone. Create the security groups The rule of thumb is least privilege: each layer accepts traffic only from the layer directly in front of it. Security group Attached to Allows inbound from Port alb-sg Anywhere on the internet 80 (HTTP), plus 443 if you add HTTPS web-sg EC2 WordPress instances alb-sg only 80 db-sg RDS MySQL database web-sg only 3306 efs-sg EFS file system 2049 (NFS) Because each group references the previous one instead of an IP range, a visitor can only reach WordPress through the Load Balancer, and only the WordPress servers can reach the database. Part 4: Database Setup, MySQL Database and EFS WordPress stores two kinds of data, and each gets its own managed service. Amazon RDS holds the content (posts, users, settings), and Amazon EFS holds the files (themes, plugins, uploads). With two web servers, shared storage matters: an image uploaded through one server must also appear on the other. Create the MySQL database on RDS Create a DB subnet group that contains the two private database subnets, one in each Availability Zone. Create the database. Choose the MySQL engine and a small instance class to keep costs low. Set the database name, the admin username and a strong password, and write them down, because WordPress needs them later. Place it in the VPC. Select your VPC and the DB subnet group, and turn off public access. Attach the db-sg security group so that only the WordPress servers can connect on port 3306. Copy the database endpoint once the instance is available. You will enter it into the WordPress configuration. Create the EFS file system Create an EFS file system in the same VPC. Create a mount target in each private application subnet, using the efs-sg security group. Note the file system ID. Both EC2 instances will mount it to share the WordPress files. Stores Posts, pages, users, settings Themes, plugins, uploaded media Managed MySQL database Shared network file system Reached by EC2 on port 3306 EC2 on port 2049 (NFS) Why it matters Content stays safe and backed up Every server shows the same files Part 5: Compute Setup, EC2 Instances and Application Load Balancer This part brings the site to life. Two EC2 instances run WordPress in private subnets, and an Application Load Balancer in the public subnets is the only door visitors use. Launch and configure the EC2 instances Launch two EC2 instances, one in each private application subnet. Attach the web-sg security group and do not assign a public IP address. Attach an IAM role to the instances so they can work securely with other AWS services. Install the web stack. Install a web server (Apache or Nginx), PHP and the MySQL client. The NAT Gateways make these downloads possible. Mount the EFS file system on the WordPress directory so both servers share the same files. Install WordPress and point its configuration file at the RDS endpoint, database name, username and password from Part 4. Create the Application Load Balancer Create a target group for HTTP on port 80 and register both EC2 instances. The health check lets the Load Balancer stop sending traffic to an unhealthy server. WordPress often redirects the home page, so accept redirect codes in the health check if it reports unhealthy. Create an internet-facing Application Load Balancer in the two public subnets with the alb-sg security group. Add a listener on port 80 that forwards traffic to the target group. Open the ALB DNS name in your browser. When both targets show as healthy, the WordPress setup page appears. Complete the WordPress installation through the ALB DNS name rather than an instance address, so the site URL WordPress saves is the one visitors will actually use. How a visitor request travels The visitor's browser sends a request to the ALB DNS name. The Load Balancer picks a healthy EC2 instance and forwards the request. WordPress on that instance reads the content from RDS and the files from EFS. The page returns to the visitor through the Load Balancer. Part 6: Conclusion and Clean-up The result is a production-style WordPress site: visitors reach it through the Load Balancer, the servers and database stay private, and two Availability Zones keep it running if one fails. What I learned • Networking is the hardest and most important part. Most problems come from route tables or security groups, so check those first when something does not connect. • Private subnets are a big security win. Nothing sensitive is reachable from the internet. • Shared storage matters. Without EFS, two WordPress servers would show different files. • High availability means duplication. Two zones, two NAT Gateways and two servers remove single points of failure. Clean up to avoid charges NAT Gateways, the RDS database and the Load Balancer are billed by the hour, even when idle. Delete resources in this order, because AWS blocks deleting something that another resource still depends on: Delete the Application Load Balancer, then its target group. Terminate both EC2 instances. Delete the RDS database. Delete the EFS mount targets, then the EFS file system. Delete both NAT Gateways, then release the Elastic IP addresses. Delete the custom security groups and route tables. Detach and delete the Internet Gateway. Delete the subnets, then the VPC. Finally, open the Billing console the next day and confirm no unexpected charges are appearing. Final thoughts Building a 3-tier architecture turned AWS from a long list of services into one system I understand. If you are learning cloud or DevOps, it is one of the best hands-on projects to start with.
Astrological forecast advising caution with decisions after 2 a.m. ET as the Moon moves into Taurus. Guidance includes focusing on spiritual renewal, career expansion in medicine or law, and avoiding petty conflicts, with specific tips for managing authority figures and finances.
The short version. Bitcoin Kisumu is a free Bitcoin education community in Kisumu, Kenya. Its website started as a repo on my personal GitHub account. This week we moved it into its own organization so anyone can contribute: separate accounts, two owners, a transferred repo, reconnected deploys, community files, branch protection, labels and seven starter issues. This post is every step with the real commands and the real output, so you can do the same wherever you are in your journey. At the end there's a list of issues you can pick up today. Who this is for Step 0: give the community its own identity Step 1: create the organization Step 2: owners and roles Step 3: move the repo in Step 4: reconnect deploys without breaking anything Step 5: the files every open-source project needs Step 6: protect the main branch Step 7: labels and first issues Step 8: make it findable The Bitcoin-specific parts What Bitcoin open source expects from you Come contribute You've never contributed to open source. Skip to What Bitcoin open source expects, then pick an issue. You only need a GitHub account. You have a project on your personal account and want others to own it with you. Follow every step in order. You run a meetup, a BitDevs or a circular economy and want a home for your site, curriculum or tools. Steps 0 to 2 and 5 to 7 matter most. Everything here uses free tiers: a free GitHub organization, the GitHub CLI (gh) and Vercel's hobby plan. A community project shouldn't depend on one person's personal logins. Before touching GitHub we created: a community email inbox (bitcoinkisumu@gmail.com); X, GitHub and Facebook accounts for Bitcoin Kisumu; a Lightning address for donations, bitcoinkisumu@blink.sv, separate from my own wallet. Lesson learned the hard way: use a separate Chrome profile for the community accounts. Halfway through, my browser was signed in to GitHub as the community account while Vercel was linked to my personal one. One "Authorize" click would have attached the wrong GitHub identity to my personal Vercel account and its other projects. I closed that tab, signed back in as myself, and moved all community logins to their own profile. Organizations are created in the browser: Go to https://github.com/account/organizations/new?plan=free. Organization name: bitcoinkisumu (it becomes github.com/bitcoinkisumu). Contact email: the community inbox, not your personal one. "This organization belongs to": My personal account (pick the business option only if a registered organization owns it). Accept the Terms of Service and click Next. GitHub then offers to invite members. You can skip it and do it in Step 2. The first thing GitHub told us on the People page: "You are the only owner of this organization! We recommend a minimum of two people within each organization have the owner role." Take that seriously. If the only owner loses access, the community loses its code. Invite the second owner from the org's People page, then accept the invitation from that account. You can accept from the terminal: gh api -X PATCH user/memberships/orgs/bitcoinkisumu -f state=active -q '.state+" "+.role' active member Invitations arrive as member. Promote to owner on the People page (⋯ → Change role → Owner), then check: gh api user/memberships/orgs/bitcoinkisumu -q '.state+" "+.role' active admin (admin is what the API calls an organization owner.) Which role for whom: Role Who should have it What they can do Owner Two or more founders Everything: billing, members, settings, transfers, deleting repos Member Regular maintainers See all non-secret repos and teams; repo access is set per repo Outside collaborator Someone helping on one repo Only the repos you add them to Contributor (no role) Anyone on the internet Fork, open issues and pull requests Inside each repo you can also give Read, Triage, Write, Maintain or Admin. A good path: contributors become Triage (they can label and close issues) after a few good reviews, then Write or Maintain once the community trusts their judgement. Transferring keeps the history, issues, pull requests and stars. You need admin rights on the repo and permission to create repos in the organization (owners have it). gh api -X POST repos/altradits/bitcoin-kisumu/transfer -f new_owner=bitcoinkisumu -q '.full_name' altradits/bitcoin-kisumu The API answers with the old name because the transfer finishes in the background. A few seconds later: gh repo view bitcoinkisumu/bitcoin-kisumu --json nameWithOwner,visibility,defaultBranchRef \ -q '.nameWithOwner+" "+.visibility+" "+.defaultBranchRef.name' bitcoinkisumu/bitcoin-kisumu PUBLIC main Old links redirect, but update your local clone so you don't rely on that: git remote set-url origin https://github.com/bitcoinkisumu/bitcoin-kisumu.git git fetch The site deploys on Vercel. After the transfer, Vercel's Git settings showed: "Error: Project Link not found." Vercel's GitHub app was installed on my personal account, not the new organization. The fix: In Vercel: project → Settings → Git → Disconnect the broken link. Click GitHub → the account list → Add GitHub Scope. On GitHub, install the Vercel app on the organization with Only select repositories → bitcoin-kisumu. Give apps the least access they need. Back in Vercel, pick the bitcoinkisumu scope and Connect the repo. Don't trust a green toast. Prove it with a real pull request and read the commit status from the terminal: sha=$(gh pr view 3 --repo bitcoinkisumu/bitcoin-kisumu --json headRefOid -q .headRefOid) gh api repos/bitcoinkisumu/bitcoin-kisumu/commits/$sha/status \ -q '.state+" "+([.statuses[]|.context]|join(","))' success Vercel Every pull request now gets its own preview link, which is a gift to reviewers. Without these, a visitor can't tell whether they're allowed to use the code or how to help. We added them in one pull request (#4): File Why it matters LICENSE (MIT) Without a license, nobody may legally reuse the code, however public it is CONTRIBUTING.md The workflow, how to review, and how roles are earned SECURITY.md Where to report problems privately, and a warning that we never ask for recovery words CODE_OF_CONDUCT.md We follow the Contributor Covenant 2.1 .github/pull_request_template.md Every PR says what changed, why, and how it was tested The contributing workflow we wrote 1. Find an issue, or open one describing what you want to change and why. 2. Fork the repo and create a branch: `git checkout -b short-description`. 3. Make one focused change. Small pull requests get reviewed faster. 4. Run the build before you push: `npm ci && npx next build`. 5. Open a pull request. Say what you changed, why, and how you tested it. Nobody, including owners, should push straight to main on a shared project. This rule requires a pull request, one approving review and a passing Vercel build, and forbids force-pushes and deleting main: cat > protect.json <<'EOF' EOF gh api -X PUT repos/bitcoinkisumu/bitcoin-kisumu/branches/main/protection --input protect.json \ -q '"reviews required: "+(.required_pull_request_reviews.required_approving_review_count|tostring)+" | checks: "+(.required_status_checks.contexts|join(","))+" | force push: "+(.allow_force_pushes.enabled|tostring)+" | admins enforced: "+(.enforce_admins.enabled|tostring)' reviews required: 1 | checks: Vercel | force push: false | admins enforced: false enforce_admins is off while we're a small team, so owners can still merge in an emergency. Turn it on once there are enough reviewers. Newcomers search for good first issue. We added labels that match the work a community site actually needs: R=bitcoinkisumu/bitcoin-kisumu gh label create translation -R $R --color 0E8A16 --description "Translate site content into Swahili, Dholuo or other languages" gh label create content -R $R --color 1D76DB --description "Writing and editing site text" gh label create design -R $R --color D876E3 --description "Visual design, images and layout" gh label create accessibility -R $R --color FBCA04 --description "Make the site usable by everyone" gh label create bitcoin-education -R $R --color F7931A --description "Teaching material about Bitcoin and Lightning" gh label list -R $R --json name -q '[.[].name]|join(", ")' bug, accessibility, documentation, duplicate, enhancement, good first issue, help wanted, invalid, question, wontfix, translation, content, design, bitcoin-education A good first issue says what, where in the code, and when it's done: gh issue create -R $R --title "Add a Lightning QR code to the Donate page" \ --label "good first issue,design,enhancement" \ --body "...Task... Where: app/donate/page.js ... Done when: scanning the QR opens a payment to bitcoinkisumu@blink.sv." We opened seven this way. They're listed at the end. gh repo edit bitcoinkisumu/bitcoin-kisumu \ --add-topic bitcoin,lightning-network,education,kenya,open-source,nextjs,hacktoberfest-friendly \ --homepage https://bitcoin-kisumu.vercel.app gh api repos/bitcoinkisumu/bitcoin-kisumu -q '"topics: "+(.topics|join(", "))' topics: bitcoin, education, hacktoberfest-friendly, kenya, lightning-network, nextjs, open-source Check your Lightning address before you print it on anything. A Lightning address is an LNURL-pay endpoint, and you can ask it directly: curl -s https://blink.sv/.well-known/lnurlp/bitcoinkisumu | python3 -c \ 'import json,sys;d=json.load(sys.stdin);print(d["tag"],d["minSendable"],d["maxSendable"],d["metadata"][:120])' payRequest 1000 50000000000 It answers as a payRequest and names itself (text/identifier), so payments really go where the poster says. Pin any third-party script that touches payments. Blink's donate button is loaded from GitHub Pages, which its owner can change at any time. We served our own copy instead, and proved it was byte-for-byte the code at a known commit: curl -sL -o live.js https://blinkbitcoin.github.io/donation-button.blink.sv/js/blink-pay-button.js gh api "repos/blinkbitcoin/donation-button.blink.sv/contents/js/blink-pay-button.js?ref=5b4a7919ee6e" \ -q .content | base64 -d > pinned.js wc -c live.js pinned.js && cmp -s live.js pinned.js && echo "live == commit 5b4a791" 163586 live.js 163586 pinned.js 327172 total The script is AGPL-3.0, so we kept it unmodified and added a README next to it naming the source, commit and license. Never hold anyone's money, and say so. Earners in our pilot are paid straight to their own wallets. SECURITY.md says we never ask for recovery words or keys: a public sentence that makes scammers' lives harder. These habits come from Bitcoin Core and LND. A small community repo is a safe place to practise them: Review with evidence. Bitcoin projects use ACK / NACK language. A tested ACK lists exactly what you ran and saw; a concept ACK agrees with the idea without testing it; a NACK says no, with a reason. "LGTM" with no detail carries little weight. Small, focused pull requests. One change, one reason. Reviewers' time is the scarcest resource in Bitcoin. Reproduce before you claim. Build it, run the tests, then comment. If something fails on your machine, show whether it also fails on main before blaming the pull request. Report security problems privately. Never in a public issue. Be patient and kind. Maintainers are volunteers. Ask precise questions, with what you tried. Read the real guides: Bitcoin Core's CONTRIBUTING.md, LND's code contribution guidelines and the Bitcoin Core PR Review Club. bitcoinkisumu / bitcoin-kisumu Free, open-source Bitcoin education for Kisumu, Kenya. A My First Bitcoin Education Network community. Bitcoin Kisumu Free, open-source Bitcoin education for Kisumu, Kenya — a community in the My First Bitcoin Education Network. Live site: https://bitcoin-kisumu.vercel.app/ Quick start cd /Users/mac/bitcoin-kisumu npm install npm run dev Open http://localhost:3000 in a browser. Production: npm run build npm start What's inside assets/ — logo kit (SVG) + brand guide. logo.svg is the Leaderboard upload. content/ — Leaderboard drafts: bio, 250-word intro, executive summary, team, socials, donate, checklist. app/ — Next.js 14 fullstack site (App Router, no external CSS framework). app/api/ — contact, newsletter, events + RSVP endpoints backed by Upstash Redis on Vercel, data/*.json locally. public/ — favicon + web logo. Pages (Education Network complete) Home, About, Programs, Events (+RSVP), Team, Donate (Lightning + Geyser), Resources, Executive Summary, Contact. Configure before launch Edit app/lib/site.js: social links, Lightning address, Geyser URL, contact email. Add team photos to public/team/. Add a high-quality community photo for Arnold's… View on GitHub Pick one, comment that you're taking it, and open a pull request: #5 Translate the Guide page into Swahili · translation good first issue #6 Add a Lightning QR code to the Donate page · good first issue design #7 Add a social preview image (Open Graph) · good first issue design #8 Accessibility check: contrast, alt text and keyboard · accessibility good first issue #9 Pilot numbers page · enhancement help wanted #10 Beginner Lightning wallet guide · content bitcoin-education #11 Translate the homepage into Dholuo · translation help wanted Not a developer? Translation, writing and accessibility checks are real contributions, and they count on your GitHub profile the same way code does. Not sponsored. Bitcoin Kisumu is a My First Bitcoin Education Network community. Site: bitcoin-kisumu.vercel.app · X: @bitcoinkisumu. To support the work: bitcoinkisumu@blink.sv ⚡