Payment integration
User base
In production
Project Snapshot.
The essential facts. Sector, timeline, surface area, and where it lives in production.
Brief, Build, and Outcome.
The Challenge
The Capitalista team needed a fundraising platform that could handle global investors, multi-currency Stripe payments, and a real-time investor dashboard all with the polish that financial users expect.
Our Approach
We built a Next.js platform optimized for trust signals, performance, and a clean dashboard experience that scales with investor count.
The Outcome
Capitalista is live at capitalista.info, serving investors globally with a real-time dashboard and end-to-end Stripe payments.
What changed.
A side-by-side of what the client had before we engaged, and what we shipped.
- Investor onboarding ran on email, PDFs, and a Google Form that asked the wrong questions for half the countries it served
- Founders manually emailed a screenshot of investor balances every Friday. Sometimes Sunday
- Wire transfers came in with mystery references; reconciling them took half a day per week
- KYC documents lived in someone's Drive folder, sorted by whoever uploaded last
- The marketing site was a Webflow template, which read like a Webflow template
- Anyone outside the EU effectively couldn't invest. Currency conversion was on them
- The team had no idea where in the funnel investors dropped off
- A guided KYC flow that asks region-specific questions and saves progress if the investor steps away mid-form
- Investors open a dashboard and see their position, returns, and last activity. Refreshed without a reload
- Stripe handles every deposit in the investor's own currency; reconciliation is automatic and the founders haven't touched a wire reference since
- All compliance documents encrypted, versioned, and tied to the investor record with an audit log
- A marketing site we wrote from scratch around the trust signals financial users actually respond to
- Investors in 14 countries can fund their position without leaving the platform
- Funnel events instrumented end-to-end. The team knows exactly which step is leaking and why
Achievements & deliverables.
Capitalista let a small team take investor money from anywhere in the world without an accountant chasing wire transfers or a founder copy-pasting balances into spreadsheets at midnight.
Multi-currency Stripe payments
Investor checkout supporting global currencies, with webhook-driven reconciliation and automated receipts.
Real-time investor dashboard
Live portfolio view with positions, returns, and activity feed refreshed without page reloads.
Compliance-aware onboarding
KYC-style flow that captures investor profile, residency, and accreditation before unlocking access.
High-performance Next.js architecture
Server-rendered pages tuned for trust signals and fast first paint the polish financial users expect.
Conversion-optimized marketing site
Above-the-fold value prop, social proof, and sign-up flow built around measurable conversion metrics.
Live globally
In production at capitalista.info, serving global investors.
How We Built It, Phase by Phase.
Every project follows a deliberate sequence. Discovery, design, foundation, build, and launch. Here is exactly what happened, and what was delivered at each step.
Mapping the Compliance Maze
Capitalista's biggest unknown wasn't engineering. It was figuring out what each region actually required before money could move. We sat with the team's compliance advisor for a full afternoon and walked out with a checklist that turned into the onboarding flow's branching logic.
- Region-by-region compliance checklist
- Currency + payment-method matrix per region
- Data model for investors, positions, and documents
- Roadmap with the compliance gates marked in red
A Design That Sells Trust
Financial users decide whether they trust you in the first three seconds. We spent more time on the marketing hero, the typography, and the empty-state copy than any other visual decisions in the project. "It looks expensive" was a real, intentional design goal.
- Marketing site, dashboard, and onboarding in one Figma file
- A type system the client could not break
- Empty / error / pending states for every dashboard view
- Motion notes. Restrained, never bouncy
Building the Foundation
Next.js with mostly server-rendered pages because investors arrive from Google searches and decide in seconds. We split the marketing site (static, edge-cached) from the dashboard (server-rendered, authenticated) so neither side compromised the other.
- Marketing pages on the edge, dashboard behind auth
- Session model that survives plan and currency changes
- Base UI from the design system
- Staging environment that mirrors production exactly
Stripe, KYC, and the Live Dashboard
We wired Stripe in two layers. The checkout for new deposits and the webhook handler for everything that happens after. The dashboard pulls from the same ledger Stripe writes to, so an investor's view is never more than a few seconds out of date. The KYC flow saves on every field. Investors can close the tab and pick up where they left off.
- Multi-currency Stripe checkout (14 countries at launch)
- Webhook handler with reconciliation report
- KYC flow with progress persistence
- Real-time portfolio dashboard + activity feed
Launch and the Funnel Work
We instrumented every step of the funnel before launch so the team could see, on day one, which step lost the most investors. The first two weeks of data led to copy changes on the deposit page that lifted conversion by a noticeable margin without us writing a line of code.
- Production launch at capitalista.info
- Funnel instrumented from landing to first deposit
- Monitoring + alerting for payment failures
- A short ops runbook for the founders
Inside Each Feature We Built.
Not just what we shipped. How it works under the hood, and the engineering decisions behind each piece.
Stripe in 14 Countries
Before Capitalista, anyone outside the EU had to handle their own currency conversion. Now an investor in Singapore funds their position in SGD and the founders see EUR in the ledger. Without anyone touching a wire reference.
- Stripe Checkout detects the investor's currency from their profile, not their IP
- Webhook handler writes ledger entries inside a single Postgres transaction. Partial failures are impossible
- Receipts auto-generated in the investor's locale and language
- A nightly reconciliation report flags any mismatch between Stripe's view and ours; it has never fired
The Dashboard That's Never Stale
Investors expect to see their money the way they see their bank account. We backed the dashboard with an append-only event log so every position change shows up the moment Stripe acknowledges it.
- Server cache invalidates on the events that actually change a position. Not on a timer
- Activity feed is a projection of the event log; we can replay history if anything looks off
- Charts use responsive, accessibility-friendly components. Readable by screen readers, printable on paper
- Fully usable on a phone, because investors check their position on the train
KYC That Doesn't Punish Investors
Most KYC forms feel hostile. We saved progress on every field so investors can close the tab, come back next week, and pick up exactly where they left off. The branching logic asks region-specific questions instead of one long form for everyone.
- Progress persisted on every field change. No "oops, you lost it" moments
- Conditional branches keyed on residency satisfy region-specific rules without bothering investors with irrelevant questions
- Compliance documents stored encrypted with a full audit trail (who uploaded, when, what version)
- Transaction access is gated on completed verification. No manual unlock required
Two Performance Budgets, One App
The marketing site has to render in milliseconds anywhere in the world. The dashboard has to render personalized data fast and never show the wrong investor. Same Next.js codebase, very different rules. And we kept them that way deliberately.
- Marketing pages statically generated and served from the edge
- Dashboard pages server-rendered, authenticated, never cached cross-user
- Images optimized with responsive variants and a tight LCP budget
- Core Web Vitals monitored continuously; regressions block deploys
A Marketing Site That Knows Where It's Losing
Every step from landing page to first deposit fires a funnel event. The first two weeks of data told the team exactly which copy was scaring people away. Two text changes lifted conversion noticeably before we wrote any new code.
- Funnel events instrumented at every decision point in the user journey
- A/B test scaffolding ready for the next round of copy experimentation
- Trust signals (regulatory notes, testimonials, team) placed where data said investors looked
- Mobile-first layout. The majority of first-touch traffic arrives on phones
Live at capitalista.info
Running today, serving investors across multiple regions and currencies. Quiet, fast, and rarely paged.
- Multi-region CDN delivery. Fast loads in Asia, Europe, and the Americas
- Currency formatting and date handling localized per region
- Region-aware compliance flows so the wrong question never gets asked
- Monitoring + alerting tuned for payments. The team gets paged for failed webhooks, not for marketing-page hiccups
Every Tool, and Why We Picked It.
A grouped breakdown of every technology in the build, with the reasoning behind each choice.
Frontend
- Next.js
Marketing pages on the edge, dashboard behind auth. One framework, two very different performance budgets.
- TypeScript
Money math and webhook payloads are both type-checked. We have not had a single "wrong currency" bug in production.
- Tailwind CSS
A type system the client cannot break by accident. Trust-first design needs consistency more than it needs flair.
Payments
- Stripe (multi-currency)
Investors check out in their own currency. Reconciliation that used to take half a Friday now happens in a background webhook.
- Webhook reconciliation
Stripe is the only thing that writes to the ledger. The dashboard reads from it. Disagreements are impossible by construction.
Dashboard
- Real-time portfolio view
Server cache invalidates on the events that actually matter. Deposit, position change, payout. Investors never see stale data.
- Activity feed
Backed by an append-only event log so the investor's view is just a projection. We can replay history if anything ever looks off.
Marketing & SEO
- Edge-cached static pages
Investors arriving from Google get a sub-second TTFB anywhere in the world. Trust starts before the page even loads.
