Databases
Databases gigs from Buxonline freelancers, starting at $1.
No gigs in this category yet.
About databases
Database work involves designing, building, maintaining and optimising the structured systems that store and retrieve information for applications, websites and organisations. A database practitioner creates schemas that define how data relates to itself, writes queries to extract exactly what's needed, ensures transactions remain consistent even under load, and tunes performance so that millions of records can be searched in milliseconds rather than minutes.
The difference between competent and poor database work shows up in how systems behave under pressure. A well-designed database handles concurrent users without locking up, scales as data grows, and protects against corruption when something fails mid-transaction. A badly structured one forces applications to do complex filtering in code, creates bottlenecks that slow every operation, or loses information when two people try to update the same record simultaneously.
This work spans relational databases like PostgreSQL and MySQL, document stores like MongoDB, key-value systems like Redis, and graph databases like Neo4j. The choice depends on access patterns: whether you need strict consistency and complex joins, flexible schema evolution, extremely fast lookups, or the ability to traverse networks of relationships efficiently. Each type solves different problems, and picking the wrong foundation creates technical debt that becomes expensive to unwind later.
Guides related to databases
Databases — questions and answers
- What's the difference between normalisation and denormalisation, and when would you use each?
- Normalisation splits data into separate tables to eliminate redundancy, so each fact exists in one place. Denormalisation deliberately duplicates data across tables to speed up reads. You normalise to prevent update anomalies and save space; you denormalise when query performance matters more than write complexity, particularly in reporting databases where data changes infrequently but gets read constantly.
- How do indexes speed up queries, and why not just index everything?
- An index creates a sorted lookup structure so the database can find rows without scanning the entire table, much like a book's index lets you jump to a topic. But every index must be updated whenever data changes, slowing inserts and updates. Indexes also consume disk space. You index columns used in WHERE clauses and joins, not every column in every table.
- What does ACID compliance actually guarantee in practice?
- ACID ensures transactions are Atomic (all changes succeed or none do), Consistent (data never violates rules), Isolated (concurrent transactions don't interfere), and Durable (committed data survives crashes). In practice, this means a bank transfer either completes fully or rolls back entirely, account balances never go negative if that's forbidden, and simultaneous withdrawals don't cause race conditions.
- Why do queries that worked fine suddenly slow down as the table grows?
- Without proper indexes, the database scans every row to find matches. With a thousand rows this takes milliseconds; with ten million it takes minutes. Growth also fragments data across disk, increases memory pressure, and makes the query planner's statistics stale. Regular maintenance—reindexing, vacuuming, updating statistics—keeps performance stable as volume increases.
- What's the practical difference between SQL and NoSQL databases for application development?
- SQL databases enforce structure through schemas and excel at complex queries joining multiple tables with guaranteed consistency. NoSQL databases trade strict consistency for flexibility and horizontal scaling, storing documents or key-value pairs without predefined structure. Choose SQL when relationships between entities matter and data integrity is critical; choose NoSQL for rapidly evolving schemas or when you need to distribute data across many servers.
- How do you migrate a live database to a new schema without downtime?
- You deploy changes in phases: first add new columns or tables while keeping old ones, then update application code to write to both, verify the migration works, switch reads to the new structure, and finally remove old columns once nothing depends on them. This expand-contract pattern lets the database evolve while the application keeps running throughout.
