Most developers build features. I'm learning to design systems.

I'm a software engineering student at the stage where the interesting questions shift — from "how do I make this work?" to "how do I make this hold?" My focus is on backend architecture, distributed application design, and blockchain infrastructure. I'm not chasing breadth. I'm deliberately deepening.

My current trajectory: grow from a developer who builds applications into an engineer who designs the structures those applications run on.

surface-level dev  →  application builder  →  [current]  →  system architect

Turning a calculator into a decision-support system

Most GPA tools compute a number. This one asks: what does that number mean for your future?

Designing a mobile-first academic analytics tool that models:

• Weighted performance tracking across semesters and credit-hours
• Degree classification risk assessment — early warnings before it's too late
• Trend projection using statistical inference, not just averages
• Career-sector mapping based on performance thresholds and field requirements

Stack: Flutter · FastAPI · Statistical Modeling
Focus: Data architecture that informs, not just reports.

Understanding trust when there's no intermediary

A modular Ethereum-based micro-lending protocol built to understand how decentralized financial systems actually work at the contract level:

• Smart contract factory pattern — deploy isolated loan instances per borrower
• On-chain reputation scoring — trust built through history, not identity
• Structured contract lifecycle — proposal → fund → repay → close, enforced in code
• Full-stack dApp integration — bridging contract logic to a real frontend

Stack: Solidity · Hardhat · Ethers.js · React
Focus: Trust modeling in zero-trust environments.

Clean architecture is invisible until it's not

A multi-API integration backend built as a deliberate exercise in structured Flask design:

• Application Factory Pattern — no circular imports, clean boot sequence
• Blueprint Modularization — News, Weather, Crypto, GitHub as isolated modules
• Service-Layer Abstraction — logic never bleeds into routes
• Environment-based configuration — dev/staging/prod separation from day one
• Glassmorphism UI — because architecture can look good too

Stack: Python · Flask · SQLAlchemy · HTML/CSS
→ View Repository

class FrankBwalya:
    """
    Software Engineering Student → System Architect in Training
    Lusaka, Zambia | 2026
    """

    trajectory = [
        "application-level development",     # ✅ done
        "backend architecture & patterns",   # ← currently here
        "distributed systems design",        # ⬜ in progress
        "smart contract ecosystems",         # ⬜ in progress
        "full system architecture",          # 🎯 destination
    ]

    engineering_focus = {
        "backend":     ["Flask", "FastAPI", "service-layer design", "API orchestration"],
        "blockchain":  ["Solidity", "Hardhat", "smart contract factories", "dApp integration"],
        "mobile":      ["Flutter", "Dart", "cross-platform architecture"],
        "data":        ["academic analytics", "statistical modeling", "decision systems"],
        "devops":      ["Docker", "CI/CD", "environment-based configuration"],
    }

    principle = (
        "I am intentionally refining previous systems rather than chasing new ones. "
        "Architectural depth over surface-level expansion."
    )

    def current_question(self) -> str:
        return "Not 'how do I build this?' — but 'how should this be designed?'"

I am actively deepening expertise in:

• Distributed systems principles — consistency models, fault tolerance, replication strategies
• Scalable backend design — service boundaries, load patterns, API contract discipline
• Smart contract security — audit patterns, invariant testing, formal verification concepts
• Containerization & deployment — Docker, CI/CD pipeline design, environment management
• Test-driven backend development — integration testing, contract testing, coverage discipline
• Data modeling for decision systems — schema design that reflects domain logic, not just storage

The objective is not tool accumulation. It is architectural fluency.

I am actively seeking:

• Backend engineering internships — production exposure across real system constraints
• Distributed systems research collaboration — theory applied to implementation
• Blockchain infrastructure projects — smart contract ecosystems with genuine use cases
• Open-source backend contributions — meaningful PRs, not surface-level fixes

If you are building structured, scalable systems — I am interested in contributing seriously, not superficially.

📧 bwalyafrank61@gmail.com · 💼 LinkedIn

My long-term interest areas converge around systems that operate under real-world constraints:

• Trust modeling in decentralized environments — what replaces institutional guarantees at the protocol level
• System reliability under constrained infrastructure — designing for contexts where resources and margin are limited
• Backend architecture for emerging markets — systems built for conditions, not assumptions
• Data-informed decision systems — where analytical modeling drives outcomes, not just dashboards

I am particularly interested in bridging formal system design principles with production-level implementation — closing the gap between theory and what actually ships.

Application Builder  →  Backend Architect  →  Distributed Systems Engineer  →  System Architect
       ✅                    [current]                 [target: 2026–27]              [horizon]

Not just code that runs. Systems that endure.

📧 Email: bwalyafrank61@gmail.com
💼 LinkedIn: Frank Bwalya
🐙 GitHub: @b5119

"Knowledge is a paradox. The more we understand, the more we realize the vastness of our ignorance."

— Viktor, Arcane

That isn't discouragement. It's the only honest description of what engineering actually is — a permanent state of knowing enough to understand how much remains. The engineers worth learning from aren't the ones who know the most. They're the ones who've stayed long enough to understand how much they don't know — and kept building anyway.

_{Last updated: 2026 · Lusaka, Zambia · Built with deliberate intent, not just enthusiasm ☕}