标签：#Fin

For the past year I worked on a remote contract with a US tech company. Paid in USD, ultimately needing Korean won. Simple, right? Then a year in, I actually reconciled what landed in my account. The exchange rate had gone up — and yet my real received amount was lower than I'd expected. I traced it, and money was leaking at every step of the transfer path I hadn't been watching. This is what I learned switching routes over that year: from a direct bank wire to Wise, the real cost difference, and one right buried in my contract. If you're a freelancer or contractor in any country earning USD from abroad, this should save you something. Money leaks in more than one place Getting USD from overseas into local currency looks like one step. It's actually at least four: The wire fee from the US bank, through correspondent banks, to the receiving bank. The exchange rate the receiving bank applies — this is the big one. The receiving fee on the destination side. A hidden "lifting charge" some correspondent banks skim. The largest is the rate. Banks quote two rates, and the "buyer rate" applied when an individual sells dollars is worse than the mid-market reference — typically a 1.5–2% spread . On $1,000, that's $15–20 gone to the rate alone. That number looks small. Accumulated over a year, it stops looking small. Route A — receiving directly through a major US bank My first setup was the simplest: the company wired USD to my US bank account, and I wired it on to my Korean bank. I picked this at contract start without much thought, assuming the client would conventionally cover fees anyway. (Lesson one: specify the transfer method, route, and who pays in the contract. ) The problem was the bank's exchange rate. It applied the buyer rate straight up, with a wider-than-usual spread versus mid-market — plus a send fee, plus the Korean receiving bank's fee. I only noticed months in. Comparing statements, there was a steady 2–3% gap between the won I'd expect at mid-market and t

Every AI coding tool can write Python — Cursor, Claude Code, Windsurf. None of them can run it safely in production. That gap between "AI wrote the code" and "the code ran safely" is exactly what I'm building jhansi.io to close. This series documents the journey. One layer of the problem at a time. The execution gap When AI generates code, four things still stand between you and prod: Dependencies — Install the right packages, with versions and licenses you trust Isolation — Run it hard-sandboxed. No host access, no outbound network, no surprises Secrets — Let AI use your API keys without ever letting it see or leak them Audit — Log every execution. Prompt, code, result, timestamp. Compliance-grade. Most teams stop at step 1. Banks and fintechs can't. FCA, SOC2, and the EU AI Act require audit trails for AI actions. You can't eval() your way through an audit. jhansi.io is the missing run() for AI-generated code. Open core, cloud sandbox, built to close each part of the gap — layer by layer. The series Part 1 — Persistent sandboxes Why "ephemeral" breaks debugging, state, and compliance. The case for giving every AI a home directory. → Read Part 1 Part 2 — Dependency management (coming soon) Detecting, installing, and locking deps across Python, Node, Go, and Java. With SBOMs and policy built in. Part 3 — Isolation (coming soon) What "hard isolation" actually means. Containers, Firecracker, zero trust networking, and the metadata service attacks you haven't thought of yet. Part 4 — Secrets (coming soon) Kernel-level proxies. AI can call Stripe without the key ever entering the sandbox. Part 5 — Audit (coming soon) Who ran what, when, with which prompt. Hash-chained logs that satisfy auditors, not just engineers. Building this in public. Follow the series on Dev.to , Linkedin , and X . Code is Apache 2.0 at github.com/jhansi-io .

Applications for Startup Battlefield 200 officially close on June 8, 11:59 p.m. PT. Don't wait any longer. Secure your shot at competing on the Disrupt Stage at TechCrunch Disrupt 2026 this October at San Francisco's Moscone West.

TL;DR Reconciliation is the part of a payments stack nobody architects for on day one and everyone pays for on day 200. The job: prove that every internal transaction matches the acquirer's settlement file, in the right currency, with the right fees, on the right value date — or surface the diff fast. The mechanics: normalize files → land into an events table → project to a read model → diff against the internal read model → buckets for ops to resolve. The boring details (file formats, fee parsing, FX rounding, value dates) are where 90% of the work lives. If you've ever opened a CSV from an acquirer at the end of the month, sorted by amount, and tried to "just match it in Excel" — yes, this post is for you. What "reconciled" actually means A transaction is reconciled when, for the same logical payment, three views agree: What you sent — your internal record of the charge/payout (your read model). What the acquirer says happened — their settlement file or API report. What the bank actually credited / debited — the bank statement. Disagreements are normal. Persistent disagreements are how you lose money slowly and never know. The shape of a settlement file Across the major acquirers, settlement files look broadly similar — and broadly different in the places that matter: Field Variants you'll see Transaction reference acquirer's transaction_id , sometimes plus a merchant_reference round-tripped from you Gross amount minor units / decimal; transaction currency vs settlement currency Fees inline per-row, or aggregated at the file footer, or in a separate fees file FX inline rate vs separate FX file; sometimes only the converted amount Value date when the bank actually moves money — often T+1/T+2 from event date Adjustments refunds, chargebacks, fee corrections, reserves — usually mixed in Encoding UTF-8 if you're lucky; CP1252 / fixed-width / SWIFT MT940 if you're not Granularity one row per transaction or daily aggregates per merchant or both There's no industry-clean

You can tap the star-shaped, NFC-enabled wand at terminals to make contactless payments. It's the first of several tap-to-pay hardware doodads coming from Cash App.

Ramp has nearly tripled its valuation over the past year as investors scramble to grab a part of the fast-growing startup.

I am a full time trader and part time developer based in Karachi, Pakistan. A year ago I sat down to research how to properly compare brokers on the Pakistan Stock Exchange. Three hours later I had 11 browser tabs open, two of which had broken links, one had data from 2019, and none of them had everything I needed in one place. So I built PSX Pulse. What PSX Pulse Is PSX Pulse is a free stock market education platform for Pakistani retail investors. Everything a beginner needs to start investing in Pakistan's stock market — in one place. What is live right now: 35 verified SECP-licensed brokers with full contact details Complete mutual funds directory across 15 AMCs DCA calculator with realistic return scenarios 30-day beginner learning path Islamic investing guide PSX sector guide covering 12 sectors IPO tracker 100-term searchable glossary Weekly market recap every Friday All free. No login required. Live at: https://psxpulse.xwen.com.pk/ The Stack React + Tailwind CSS for the frontend. Vercel for hosting — free tier handles everything comfortably. No backend for most features — localStorage and static data keeps it fast and simple. Newsletter handled via a serverless Vercel function writing to a private GitHub CSV. What I Learned Building This Solo 1. The information gap in emerging markets is enormous Pakistani investors are not underserved because nobody cares. They are underserved because nobody with the technical skills to build tools also has the market knowledge to know what those tools should do. Being both a trader and a developer turned out to be the actual unfair advantage. 2. Free tools beat content for SEO My DCA calculator and broker directory pages get more consistent Google clicks than any article I have written. Tools solve a specific search intent that AI overviews do not replace — people still need to interact with a calculator, not just read about one. 3. Building in public is uncomfortable but worth it Sharing what you are building before it i

Quantinuum, a quantum computing startup, is losing millions. Investors want in anyway.

The Bengaluru startup has crossed 1 million orders and reached a $50 million annualized GMV run rate within a year of launch.

This is a submission for the GitHub Finish-Up-A-Thon Challenge I wired edge-context-mode into my own...

⚠️ この記事はアフィリエイト広告（プロモーション）を含みます。リンク先で発生した収益の一部が運営者に支払われますが、読者の購入価格には一切影響ありません。 If you work remote from rural Japan, by the end of this article you'll have two runnable Python scripts: one that computes your exact furusato-nozei (hometown tax) ceiling from your real side-income, and one that scores your electricity contract against your actual kWh log so you stop overpaying. No spreadsheets, no "consult a tax accountant" hand-waving. Copy, run, save money tonight. Result from my own 2025 numbers: ¥41,000 of furusato-nozei reward goods for a net cost of ¥2,000, plus ¥28,400/year shaved off my power bill after switching plans. Total ≈ ¥67,400 recovered, and because I work from home in Niigata, my commute cost to earn it was literally ¥0. The trap: side income breaks the "simple" furusato nozei calculator Every portal (Satofuru, Rakuten Furusato, Furunavi) shows a slider that estimates your ceiling from salary alone. The moment you add freelance/blog/ Kindle income, that slider lies to you. In 2024 I trusted it, donated ¥52,000, and ¥9,000 of it fell outside the deductible ceiling because my side income pushed me into a different residual-tax bracket. That ¥9,000 was just a donation — no tax back. The real ceiling depends on your total taxable income (salary + side hustle minus expenses) and the resident-tax (juminzei) cap of roughly 20% of your income-based resident tax. Here's a calculator that actually folds in side income. It uses Japan's 2026 progressive income-tax brackets. # furusato_ceiling.py — Python 3.9+ from dataclasses import dataclass # 2026 national income tax brackets: (upper_bound_yen, rate, deduction_yen) BRACKETS = [ ( 1_950_000 , 0.05 , 0 ), ( 3_300_000 , 0.10 , 97_500 ), ( 6_950_000 , 0.20 , 427_500 ), ( 9_000_000 , 0.23 , 636_000 ), ( 18_000_000 , 0.33 , 1_536_000 ), ( 40_000_000 , 0.40 , 2_796_000 ), ( float ( " inf " ), 0.45 , 4_796_000 ), ] @dataclass class Taxpayer : salary_income : int # after salary-income deduction (給与所得) side_profit : int #

The British fintech has built a waitlist of about 450,000 users in India as it prepares for a broader launch.

Originally published on rikuq.com . Republished here for Dev.to's readers. The FinOps Foundation Framework is the reference architecture for cloud financial management. It's been maintained by the FinOps Foundation (a Linux Foundation project) since 2018 and has matured into the de facto standard most serious cloud cost work is built on. In 2026 it received a substantial refresh that extended its scope from pure cloud spend to include AI/ML, SaaS, licensing, and broader technology categories. For practitioners thinking about formalising FinOps practice — or evaluating providers who claim to do FinOps — knowing what the Framework actually covers is what separates a real implementation from a marketing label. This post walks through the Framework structure, the 2026 updates, and how it applies specifically to AI/ML spend. I'm Ravi. I run three production AI SaaS solo ( Prism , Citare , BatchWise ) and do advisory work on FinOps via rikuq services . The walkthrough below is what I use when teams ask "what does the FinOps Foundation Framework actually look like in practice?" TL;DR Element What it is Phases Three concurrent operational modes: Inform, Optimize, Operate Principles Six foundational principles guiding all FinOps practice Capabilities The functional areas of activity a FinOps practice covers Personas Engineering, Finance, Procurement, Leadership, Operations, ITAM, Sustainability 2026 additions Executive Strategy Alignment, Technology Categories taxonomy, Converging Disciplines recognition AI/ML extension New Technology Category with specifics on GPU/CPU differential, token pricing, make-vs-buy economics The six foundational principles Before the structural mechanics, the Framework's six principles establish the cultural and operational mindset. They're worth knowing because they're how the Framework's authors test whether something is "really" FinOps or just cloud cost cutting. Teams need to collaborate. Engineering, Finance, Procurement, and Business teams w

Most people understand that a Compute Savings Plan saves money on cloud compute. Far fewer understand the precise mechanism which matters, because getting the commitment amount wrong in either direction costs real money. Too high: you pay for committed hours you do not use. Too low: you miss savings on usage that could have been covered. The difference between a well-sized Savings Plan and a poorly-sized one can easily be tens of thousands of dollars per year on a mid-size fleet. This guide walks through the exact mechanics, hour by hour, with worked examples on both AWS and Azure. Step 1: You Choose a Commitment Amount Before anything else, you decide how much per hour you want to commit. This is the single most important decision in the entire process. Everything else is automatic, the discount application, the coverage calculation, the billing. The commitment amount is a dollar figure: $X per hour. It represents a minimum spend level. You are telling the cloud provider: every hour for the next 1 year (or 3 years), I guarantee I will use at least this much compute. The right commitment amount is your stable baseline, not your average and not your peak. Pull your last 30 days of hourly compute spend. Sort the values. Find the P70 or P75: the spend level you are at or above for 70–75% of hours. That is roughly where your commitment should sit. Why P70–P75 and not the average? Because the average includes your peak hours and your quietest hours equally. If you commit to the average, you generate wasted commitment in the bottom 50% of hours. At P70, you are paying for unused commitment in only 30% of hours and those hours only waste the difference between actual usage and committed amount, not the full committed amount. If you want to understand how commitment-based discounts work across AWS, Azure, and GCP, we covered the full landscape here What Are Commitment-Based Discounts in Multi-Cloud Services? Step 2: The Cloud Provider Applies Discounted Rates Once you have

Someone asked us a sharp question on X this week. Tokenized stocks will drop dividends straight on-chain, so do we see any downsides? It's a fair question, and the honest answer is yes, one big one. The downside isn't the dividend itself. Instant, programmatic, no broker statement to wait for: that part is genuinely good. The downside is that you can't see it. On-chain dividends for tokenized equities are silent. They arrive without a transaction, without a notification, without anything landing in your wallet history. And a payment you never see is a payment you never declare. That's not a tracking annoyance. It's a tax problem, and it gets expensive. The dividend that never sent a transaction Backed Finance's xStocks (the Xs-prefixed mints like AAPLx, TSLAx, NVDAx) and Ondo Global Markets equities (the ondo-suffixed mints) both use the SPL Token-2022 ScaledUiAmount extension. It's an elegant piece of engineering. When the underlying stock pays a dividend, the issuer doesn't airdrop tokens to thousands of wallets. It updates a single number, a multiplier, on the mint account itself. The instant that multiplier changes, every wallet holding the token shows a larger balance. Your 10 shares are now worth the equivalent of 10 shares plus the reinvested dividend. No transfer hit your wallet. No transaction was signed. Nothing appeared in your activity feed. The number simply went up. Compare that with a traditional brokerage. When Apple pays a dividend, you get a line on a statement, an email, a figure on a 1099 or an annual tax summary. The paperwork chases you. On-chain, nothing chases you. The dividend is real, it's yours, and the only evidence it happened is a multiplier value buried in an on-chain mint account that almost nobody thinks to read. Why a number going up is a taxable event Here's the part that catches people. Dividend income is ordinary income. It's taxable in the year you receive it, at your marginal rate, in every jurisdiction we serve: Australia, the

GitHub reports cutting token costs in agentic CI workflows by up to 62% by pruning unused MCP tools, swapping some MCP calls for gh CLI, and running daily “auditor” and “optimizer” agents. A token-usage.jsonl artefact and an Effective Tokens metric help track spend across models and spot regressions. By Mark Silvester

Most software projects focus on producing outputs. Most AI projects focus on producing predictions. But real organizations don't operate on outputs or predictions alone. They operate on decisions. A decision has consequences. A decision creates risk. A decision consumes resources. A decision changes the future state of a system. Over the last few months, I've been studying and building systems around a simple question: How can we make decisions more explainable, auditable, and repeatable? This led me toward concepts such as: event-driven architectures decision logging risk evaluation pipelines audit trails feedback loops operational intelligence systems Instead of asking: "Can we predict what will happen?" I'm becoming more interested in asking: "Can we explain why a decision was made?" and "Can we reproduce that decision six months later?" Current areas I'm exploring: Financial decision systems Risk infrastructure Event-driven architectures Blockchain compliance workflows Operational intelligence platforms One of the projects I'm currently building is an Event-Driven Decision Logging System (EDDL), designed to explore how organizations can record, audit, and replay critical decisions over time. Still learning. Still building. Still refining my understanding of how complex systems operate under uncertainty. Looking forward to sharing the journey here. systemsdesign #architecture #backend #fintech #softwareengineering #eventdriven #riskmanagement

The port seems solid, and all DLC is supported—but there's no crossplay, sadly.

Platform team sprint planning in 2026 begins with budget allocation, not architecture review. The first question is no longer "what do we need to build?" — it's "what can we afford to run?" This is not FinOps adoption. This is authority displacement. The platform team became a finance team because the control plane for infrastructure decisions migrated from architecture governance to budget governance. Cost constraints don't inform architectural decisions anymore — they dictate them. And when financial systems gain veto authority over technical systems, resilience becomes the variable that adjusts. Platform team cost governance is now the primary control surface. Architecture is secondary. How We Got Here The timeline is sharper than most organizations admit. 2018–2022 was the cloud adoption phase. Platform teams built for scale. Multi-region resilience was standard. Observability was deep. Auto-scaling was elastic. Architectural requirements shaped cost models. The budget followed the design. 2023–2024 brought FinOps as a cost visibility layer. Teams could finally see where money was going. Dashboards got built. Anomaly detection got configured. Attribution models got refined. But visibility was still separate from authority. The FinOps team reported. The platform team decided. 2025–2026 is when cost governance moved from reporting to gating. The turning point: platform teams stopped asking "can we build this?" and started asking "can we afford this?" Engineering roadmaps became cost roadmaps. Feature requests now come with budget allocation approvals. Architecture reviews now include CFO sign-off gates. This shift introduced Budget-Normalized Architecture — systems designed around predictable monthly spend targets instead of operational resilience targets. The architecture no longer optimizes for failure domains, latency requirements, or recovery objectives. It optimizes for staying under the cost ceiling. Cost governance expanded because engineering governance fa

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built Photremium is an all-in-one, lightning-fast web utility platform engineered for high-performance image processing. Built to eliminate the friction of clunky, ad-heavy design tools, it provides users with instantaneous, client-side and serverless tools like high-fidelity background removal, image resizing, custom QR code generation and many more. As a software engineering student, this project represents my vision of creating a modern production platform that prioritizes raw speed, high usability, and robust SEO architectural patterns. Live Platform: photremium.com GitHub Repository: itsaminaziz/photremium.com Demo The Live Application Experience the full toolset live right now at photremium.com . Key Features in Action Feature Implementation Speed / Processing Compress IMAGE Client-side Canvas / Web Workers Instantaneous local compression Resize IMAGE Client-side React & HTML5 Canvas Real-time pixel/percent adjustment Crop IMAGE Client-side UI & Visual Crop Editor Instantaneous browser-based cropping Convert to JPG Client-side File Readers (Bulk Upload) Instant batch conversion via browser Convert from JPG Client-side Canvas (PNG/GIF compiler) Multi-format local generation QR Code Generator Vector-based SVG/Canvas rendering Instant download generation QR Code Scanner Client-side WebRTC Camera / File API Real-time local camera processing Blur Face Hybrid Client-side Face Detection Instant local privacy overlay mapping Remove Background (AI) Cloud-based Serverless / Cloudflare Edge < 2 seconds (Any device image processing) Watermark IMAGE Client-side Layer Composition Instantaneous text/graphic stamping The Comeback Story The Before (A Half-Baked Local App) Photremium started as an ambitious prototype on a local machine. While the fundamental image-processing utilities worked locally, the project hit a massive wall when it came to global deployment and production readiness. It was plagued with